package com.xuan.core.bazi;

import java.util.*;

/**
 * 八字-常量
 *
 * @author 善待
 */
public class BaZiMaps {

    /**
     * 天干五行
     */
    public static final Map<String, String> GAN_WU_XING = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("甲", "木");
            put("乙", "木");
            put("丙", "火");
            put("丁", "火");
            put("戊", "土");
            put("己", "土");
            put("庚", "金");
            put("辛", "金");
            put("壬", "水");
            put("癸", "水");
        }
    };

    /**
     * 地支五行
     */
    public static final Map<String, String> ZHI_WU_XING = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子", "水");
            put("丑", "土");
            put("寅", "木");
            put("卯", "木");
            put("辰", "土");
            put("巳", "火");
            put("午", "火");
            put("未", "土");
            put("申", "金");
            put("酉", "金");
            put("戌", "土");
            put("亥", "水");
        }
    };

//----------------------------------------------------------------------------------------------------------------------------------------------------

    /**
     * 天干相生（天干+天干为键）
     */
    public static final Map<String, String> TIAN_GAN_XIANG_SHENG = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("甲丁", "甲丁相生");
            put("乙丙", "乙丙相生");
            put("丙己", "丙己相生");
            put("丁戊", "丁戊相生");
            put("戊辛", "戊辛相生");
            put("己庚", "己庚相生");
            put("庚癸", "庚癸相生");
            put("辛壬", "辛壬相生");
            put("壬乙", "壬乙相生");
            put("癸甲", "癸甲相生");
        }
    };

    /**
     * 天干相合（天干+天干为键）
     */
    public static final Map<String, String> TIAN_GAN_XIANG_HE = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("甲己", "甲己合化土");
            put("乙庚", "乙庚合化金");
            put("丙辛", "丙辛合化水");
            put("丁壬", "丁壬合化木");
            put("戊癸", "戊癸合化火");
        }
    };

    /**
     * 天干相冲（天干+天干为键）
     */
    public static final Map<String, String> TIAN_GAN_XIANG_CHONG = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("甲庚", "甲庚相冲");
            put("乙辛", "乙辛相冲");
            put("丙壬", "丙壬相冲");
            put("丁癸", "丁癸相冲");
        }
    };

    /**
     * 天干相克（天干+天干为键）
     */
    public static final Map<String, String> TIAN_GAN_XIANG_KE = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("甲戊", "甲戊相克");
            put("乙己", "乙己相克");
            put("丙庚", "丙庚相克");
            put("丁辛", "丁辛相克");
            put("戊壬", "戊壬相克");
            put("己癸", "己癸相克");
            put("庚甲", "庚甲相克");
            put("辛乙", "辛乙相克");
            put("壬丙", "壬丙相克");
            put("癸丁", "癸丁相克");
        }
    };

//----------------------------------------------------------------------------------------------------------------------------------------------------

    /**
     * 地支三合（地支+地支为键）
     */
    public static final Map<String, String> DI_ZHI_SAN_HE = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("寅午", "寅午半合火局 | 生地半合");
            put("申子", "申子半合水局 | 生地半合");
            put("巳酉", "巳酉半合金局 | 生地半合");
            put("亥卯", "亥卯半合木局 | 生地半合");
            put("子辰", "子辰半合水局 | 墓地半合");
            put("午戌", "午戌半合火局 | 墓地半合");
            put("卯未", "卯未半合木局 | 墓地半合");
            put("酉丑", "酉丑半合金局 | 墓地半合");
        }
    };

    /**
     * 地支六合（地支+地支为键）
     */
    public static final Map<String, String> DI_ZHI_LIU_HE = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子丑", "子丑合化土");
            put("寅亥", "寅亥合化木");
            put("卯戌", "卯戌合化火");
            put("辰酉", "辰酉合化金");
            put("巳申", "巳申合化水");
            put("午未", "午未合化土");
        }
    };

    /**
     * 地支相冲（地支+地支为键）
     */
    public static final Map<String, String> DI_ZHI_XIANG_CHONG = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子午", "子午相冲");
            put("丑未", "丑未相冲");
            put("寅申", "寅申相冲");
            put("卯酉", "卯酉相冲");
            put("辰戌", "辰戌相冲");
            put("巳亥", "巳亥相冲");
        }
    };

    /**
     * 地支相破（地支+地支为键）
     */
    public static final Map<String, String> DI_ZHI_XIANG_PO = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子酉", "子酉相破");
            put("寅亥", "寅亥相破");
            put("卯午", "卯午相破");
            put("辰丑", "辰丑相破");
            put("巳申", "巳申相破");
            put("戌未", "戌未相破");
        }
    };

    /**
     * 地支相害（地支+地支为键）
     */
    public static final Map<String, String> DI_ZHI_XIANG_HAI = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子未", "子未相害");
            put("丑午", "丑午相害");
            put("寅巳", "寅巳相害");
            put("卯辰", "卯辰相害");
            put("申亥", "申亥相害");
            put("酉戌", "酉戌相害");
        }
    };

//----------------------------------------------------------------------------------------------------------------------------------------------------

    /**
     * 天干和干支的五行生克关系（天干+干支为键）
     */
    public static final Map<String, String> GAN_ZHI_WU_XING_SHENG_KE = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            一、身强：同我、生我。

            二、身弱：克我、我生、我克。
               1、克我为：克。
               2、我生为：泄。
               3、我克为：耗。
         */ {
            put("甲甲", "身强"); // 甲+甲：身强（同我。甲同甲→木同木）
            put("甲乙", "身强"); // 甲+乙：身强（同我。甲同乙→木同木）
            put("甲丙", "身弱"); // 甲+丙：身弱（我生。甲生丙→木生火）
            put("甲丁", "身弱"); // 甲+丁：身弱（我生。甲生丁→木生火）
            put("甲戊", "身弱"); // 甲+戊：身弱（我克。甲克戌→木克土）
            put("甲己", "身弱"); // 甲+己：身弱（我克。甲克己→木克土）
            put("甲庚", "身弱"); // 甲+庚：身弱（克我。庚克甲→金克木）
            put("甲辛", "身弱"); // 甲+辛：身弱（克我。辛克甲→金克木）
            put("甲壬", "身强"); // 甲+壬：身强（生我。壬生甲→水生木）
            put("甲癸", "身强"); // 甲+癸：身强（生我。癸生甲→水生木）
            put("甲子", "身强"); // 甲+子：身强（生我。子生甲→水生木）
            put("甲丑", "身弱"); // 甲+丑：身弱（我克。甲克丑→木克土）
            put("甲寅", "身强"); // 甲+寅：身强（同我。甲同寅→木同木）
            put("甲卯", "身强"); // 甲+卯：身强（同我。甲同卯→木同木）
            put("甲辰", "身弱"); // 甲+辰：身弱（我克。甲克辰→木克土）
            put("甲巳", "身弱"); // 甲+巳：身弱（我生。甲生巳→木生火）
            put("甲午", "身弱"); // 甲+午：身弱（我生。甲生午→木生火）
            put("甲未", "身弱"); // 甲+未：身弱（我克。甲克未→木克土）
            put("甲申", "身弱"); // 甲+申：身弱（克我。申克甲→金克木）
            put("甲酉", "身弱"); // 甲+酉：身弱（克我。酉克甲→金克木）
            put("甲戌", "身弱"); // 甲+戌：身弱（我克。甲克戌→木克土）
            put("甲亥", "身强"); // 甲+亥：身强（生我。亥生甲→水生木）
            put("乙甲", "身强"); // 乙+甲：身强（同我。乙同甲→木同木）
            put("乙乙", "身强"); // 乙+乙：身强（同我。乙同乙→木同木）
            put("乙丙", "身弱"); // 乙+丙：身弱（我生。乙生丙→木生火）
            put("乙丁", "身弱"); // 乙+丁：身弱（我生。乙生丁→木生火）
            put("乙戊", "身弱"); // 乙+戊：身弱（我克。乙克戌→木克土）
            put("乙己", "身弱"); // 乙+己：身弱（我克。乙克己→木克土）
            put("乙庚", "身弱"); // 乙+庚：身弱（克我。庚克乙→金克木）
            put("乙辛", "身弱"); // 乙+辛：身弱（克我。辛克乙→金克木）
            put("乙壬", "身强"); // 乙+壬：身强（生我。壬生乙→水生木）
            put("乙癸", "身强"); // 乙+癸：身强（生我。癸生乙→水生木）
            put("乙子", "身强"); // 乙+子：身强（生我。子生乙→水生木）
            put("乙丑", "身弱"); // 乙+丑：身弱（我克。乙克丑→木克土）
            put("乙寅", "身强"); // 乙+寅：身强（同我。乙同寅→木同木）
            put("乙卯", "身强"); // 乙+卯：身强（同我。乙同卯→木同木）
            put("乙辰", "身弱"); // 乙+辰：身弱（我克。乙克辰→木克土）
            put("乙巳", "身弱"); // 乙+巳：身弱（我生。乙生巳→木生火）
            put("乙午", "身弱"); // 乙+午：身弱（我生。乙生午→木生火）
            put("乙未", "身弱"); // 乙+未：身弱（我克。乙克未→木克土）
            put("乙申", "身弱"); // 乙+申：身弱（克我。申克乙→金克木）
            put("乙酉", "身弱"); // 乙+酉：身弱（克我。酉克乙→金克木）
            put("乙戌", "身弱"); // 乙+戌：身弱（我克。乙克戌→木克土）
            put("乙亥", "身强"); // 乙+亥：身强（生我。亥生乙→水生木）
            put("丙甲", "身强"); // 丙+甲：身强（生我。甲生丙→木生火）
            put("丙乙", "身强"); // 丙+乙：身强（生我。乙生丙→木生火）
            put("丙丙", "身强"); // 丙+丙：身强（同我。丙同丙→火同火）
            put("丙丁", "身强"); // 丙+丁：身强（同我。丙同丁→火同火）
            put("丙戊", "身弱"); // 丙+戊：身弱（我生。丙生戊→火生土）
            put("丙己", "身弱"); // 丙+己：身弱（我生。丙生己→火生土）
            put("丙庚", "身弱"); // 丙+庚：身弱（我克。丙克庚→火克金）
            put("丙辛", "身弱"); // 丙+辛：身弱（我克。丙克辛→火克金）
            put("丙壬", "身弱"); // 丙+壬：身弱（克我。壬克丙→水克火）
            put("丙癸", "身弱"); // 丙+癸：身弱（克我。癸克丙→水克火）
            put("丙子", "身弱"); // 丙+子：身弱（克我。子克丙→水克火）
            put("丙丑", "身弱"); // 丙+丑：身弱（我生。丙生丑→火生土）
            put("丙寅", "身强"); // 丙+寅：身强（生我。丙生寅→木生火）
            put("丙卯", "身强"); // 丙+卯：身强（生我。丙生卯→木生火）
            put("丙辰", "身弱"); // 丙+辰：身弱（我生。丙生辰→火生土）
            put("丙巳", "身强"); // 丙+巳：身强（同我。丙同巳→火同火）
            put("丙午", "身强"); // 丙+午：身强（同我。丙同午→火同火）
            put("丙未", "身弱"); // 丙+未：身弱（我生。丙生未→火生土）
            put("丙申", "身弱"); // 丙+申：身弱（我克。丙克申→火克金）
            put("丙酉", "身弱"); // 丙+酉：身弱（我克。丙克酉→火克金）
            put("丙戌", "身弱"); // 丙+戌：身弱（我生。丙生戌→火生土）
            put("丙亥", "身弱"); // 丙+亥：身弱（克我。亥克丙→水克火）
            put("丁甲", "身强"); // 丁+甲：身强（生我。甲生丁→木生火）
            put("丁乙", "身强"); // 丁+乙：身强（生我。乙生丁→木生火）
            put("丁丙", "身强"); // 丁+丙：身强（同我。丁同丙→火同火）
            put("丁丁", "身强"); // 丁+丁：身强（同我。丁同丁→火同火）
            put("丁戊", "身弱"); // 丁+戊：身弱（我生。丁生戊→火生土）
            put("丁己", "身弱"); // 丁+己：身弱（我生。丁生己→火生土）
            put("丁庚", "身弱"); // 丁+庚：身弱（我克。丁克庚→火克金）
            put("丁辛", "身弱"); // 丁+辛：身弱（我克。丁克辛→火克金）
            put("丁壬", "身弱"); // 丁+壬：身弱（克我。壬克丁→水克火）
            put("丁癸", "身弱"); // 丁+癸：身弱（克我。癸克丁→水克火）
            put("丁子", "身弱"); // 丁+子：身弱（克我。子克丁→水克火）
            put("丁丑", "身弱"); // 丁+丑：身弱（我生。丁生丑→火生土）
            put("丁寅", "身强"); // 丁+寅：身强（生我。丁生寅→木生火）
            put("丁卯", "身强"); // 丁+卯：身强（生我。丁生卯→木生火）
            put("丁辰", "身弱"); // 丁+辰：身弱（我生。丁生辰→火生土）
            put("丁巳", "身强"); // 丁+巳：身强（同我。丁同巳→火同火）
            put("丁午", "身强"); // 丁+午：身强（同我。丁同午→火同火）
            put("丁未", "身弱"); // 丁+未：身弱（我生。丁生未→火生土）
            put("丁申", "身弱"); // 丁+申：身弱（我克。丁克申→火克金）
            put("丁酉", "身弱"); // 丁+酉：身弱（我克。丁克酉→火克金）
            put("丁戌", "身弱"); // 丁+戌：身弱（我生。丁生戌→火生土）
            put("丁亥", "身弱"); // 丁+亥：身弱（克我。亥克丁→水克火）
            put("戊甲", "身弱"); // 戊+甲：身弱（克我。甲克戊→木克土）
            put("戊乙", "身弱"); // 戊+乙：身弱（克我。乙克戊→木克土）
            put("戊丙", "身强"); // 戊+丙：身强（生我。丙生戊→火生土）
            put("戊丁", "身强"); // 戊+丁：身强（生我。丁生戊→火生土）
            put("戊戊", "身强"); // 戊+戊：身强（同我。戊同戊→土同土）
            put("戊己", "身强"); // 戊+己：身强（同我。戊同己→土同土）
            put("戊庚", "身弱"); // 戊+庚：身弱（我生。戊生庚→土生金）
            put("戊辛", "身弱"); // 戊+辛：身弱（我生。戊生辛→土生金）
            put("戊壬", "身弱"); // 戊+壬：身弱（我克。戊克壬→土克水）
            put("戊癸", "身弱"); // 戊+癸：身弱（我克。戊克癸→土克水）
            put("戊子", "身弱"); // 戊+子：身弱（我克。戊克子→土克水）
            put("戊丑", "身强"); // 戊+丑：身强（同我。戊同丑→土同土）
            put("戊寅", "身弱"); // 戊+寅：身弱（克我。寅克戊→木克土）
            put("戊卯", "身弱"); // 戊+卯：身弱（克我。卯克戊→木克土）
            put("戊辰", "身强"); // 戊+辰：身强（同我。戊同辰→土同土）
            put("戊巳", "身强"); // 戊+巳：身强（生我。巳生戊→火生土）
            put("戊午", "身强"); // 戊+午：身强（生我。午生戊→火生土）
            put("戊未", "身强"); // 戊+未：身强（同我。戊同未→土同土）
            put("戊申", "身弱"); // 戊+申：身弱（我生。戊生申→土生金）
            put("戊酉", "身弱"); // 戊+酉：身弱（我生。戊生酉→土生金）
            put("戊戌", "身强"); // 戊+戌：身强（同我。戊同戌→土同土）
            put("戊亥", "身弱"); // 戊+亥：身弱（我克。戊克亥→土克水）
            put("己甲", "身弱"); // 己+甲：身弱（克我。甲克己→木克土）
            put("己乙", "身弱"); // 己+乙：身弱（克我。乙克己→木克土）
            put("己丙", "身强"); // 己+丙：身强（生我。丙生己→火生土）
            put("己丁", "身强"); // 己+丁：身强（生我。丁生己→火生土）
            put("己戊", "身强"); // 己+戊：身强（同我。己同戊→土同土）
            put("己己", "身强"); // 己+己：身强（同我。己同己→土同土）
            put("己庚", "身弱"); // 己+庚：身弱（我生。己生庚→土生金）
            put("己辛", "身弱"); // 己+辛：身弱（我生。己生辛→土生金）
            put("己壬", "身弱"); // 己+壬：身弱（我克。己克壬→土克水）
            put("己癸", "身弱"); // 己+癸：身弱（我克。己克癸→土克水）
            put("己子", "身弱"); // 己+子：身弱（我克。己克子→土克水）
            put("己丑", "身强"); // 己+丑：身强（同我。己同丑→土同土）
            put("己寅", "身弱"); // 己+寅：身弱（克我。寅克己→木克土）
            put("己卯", "身弱"); // 己+卯：身弱（克我。卯克己→木克土）
            put("己辰", "身强"); // 己+辰：身强（同我。己同辰→土同土）
            put("己巳", "身强"); // 己+巳：身强（生我。巳生己→火生土）
            put("己午", "身强"); // 己+午：身强（生我。午生己→火生土）
            put("己未", "身强"); // 己+未：身强（同我。己同未→土同土）
            put("己申", "身弱"); // 己+申：身弱（我生。己生申→土生金）
            put("己酉", "身弱"); // 己+酉：身弱（我生。己生酉→土生金）
            put("己戌", "身强"); // 己+戌：身强（同我。己同戌→土同土）
            put("己亥", "身弱"); // 己+亥：身弱（我克。己克亥→土克水）
            put("庚甲", "身弱"); // 庚+甲：身弱（我克。庚克甲→金克木）
            put("庚乙", "身弱"); // 庚+乙：身弱（我克。庚克乙→金克木）
            put("庚丙", "身弱"); // 庚+丙：身弱（克我。丙克庚→火克金）
            put("庚丁", "身弱"); // 庚+丁：身弱（克我。丁克庚→火克金）
            put("庚戊", "身强"); // 庚+戊：身强（生我。戊生庚→土生金）
            put("庚己", "身强"); // 庚+己：身强（生我。己生庚→土生金）
            put("庚庚", "身强"); // 庚+庚：身强（同我。庚同庚→金同金）
            put("庚辛", "身强"); // 庚+辛：身强（同我。庚同辛→金同金）
            put("庚壬", "身弱"); // 庚+壬：身弱（我生。庚生壬→金生水）
            put("庚癸", "身弱"); // 庚+癸：身弱（我生。庚生癸→金生水）
            put("庚子", "身弱"); // 庚+子：身弱（我生。庚生子→金生水）
            put("庚丑", "身强"); // 庚+丑：身强（生我。丑生庚→土生金）
            put("庚寅", "身弱"); // 庚+寅：身弱（我克。庚克寅→金克木）
            put("庚卯", "身弱"); // 庚+卯：身弱（我克。庚克卯→金克木）
            put("庚辰", "身强"); // 庚+辰：身强（生我。辰生庚→土生金）
            put("庚巳", "身弱"); // 庚+巳：身弱（克我。巳克庚→火克金）
            put("庚午", "身弱"); // 庚+午：身弱（克我。午克庚→火克金）
            put("庚未", "身强"); // 庚+未：身强（生我。未生庚→土生金）
            put("庚申", "身强"); // 庚+申：身强（同我。庚同申→金同金）
            put("庚酉", "身强"); // 庚+酉：身强（同我。庚同酉→金同金）
            put("庚戌", "身强"); // 庚+戌：身强（生我。戌生庚→土生金）
            put("庚亥", "身弱"); // 庚+亥：身弱（我生。庚生亥→金生水）
            put("辛甲", "身弱"); // 辛+甲：身弱（我克。辛克甲→金克木）
            put("辛乙", "身弱"); // 辛+乙：身弱（我克。辛克乙→金克木）
            put("辛丙", "身弱"); // 辛+丙：身弱（克我。丙克辛→火克金）
            put("辛丁", "身弱"); // 辛+丁：身弱（克我。丁克辛→火克金）
            put("辛戊", "身强"); // 辛+戊：身强（生我。戊生辛→土生金）
            put("辛己", "身强"); // 辛+己：身强（生我。己生辛→土生金）
            put("辛庚", "身强"); // 辛+庚：身强（同我。辛同庚→金同金）
            put("辛辛", "身强"); // 辛+辛：身强（同我。辛同辛→金同金）
            put("辛壬", "身弱"); // 辛+壬：身弱（我生。辛生壬→金生水）
            put("辛癸", "身弱"); // 辛+癸：身弱（我生。辛生癸→金生水）
            put("辛子", "身弱"); // 辛+子：身弱（我生。辛生子→金生水）
            put("辛丑", "身强"); // 辛+丑：身强（生我。丑生辛→土生金）
            put("辛寅", "身弱"); // 辛+寅：身弱（我克。辛克寅→金克木）
            put("辛卯", "身弱"); // 辛+卯：身弱（我克。辛克卯→金克木）
            put("辛辰", "身强"); // 辛+辰：身强（生我。辰生辛→土生金）
            put("辛巳", "身弱"); // 辛+巳：身弱（克我。巳克辛→火克金）
            put("辛午", "身弱"); // 辛+午：身弱（克我。午克辛→火克金）
            put("辛未", "身强"); // 辛+未：身强（生我。未生辛→土生金）
            put("辛申", "身强"); // 辛+申：身强（同我。辛同申→金同金）
            put("辛酉", "身强"); // 辛+酉：身强（同我。辛同酉→金同金）
            put("辛戌", "身强"); // 辛+戌：身强（生我。戌生辛→土生金）
            put("辛亥", "身弱"); // 辛+亥：身弱（我生。辛生亥→金生水）
            put("壬甲", "身弱"); // 壬+甲：身弱（我生。壬生甲→水生木）
            put("壬乙", "身弱"); // 壬+乙：身弱（我生。壬生乙→水生木）
            put("壬丙", "身弱"); // 壬+丙：身弱（我克。壬克丙→水克火）
            put("壬丁", "身弱"); // 壬+丁：身弱（我克。壬克丁→水克火）
            put("壬戊", "身弱"); // 壬+戊：身弱（克我。戊克壬→土克水）
            put("壬己", "身弱"); // 壬+己：身弱（克我。己克壬→土克水）
            put("壬庚", "身强"); // 壬+庚：身强（生我。庚生壬→金生水）
            put("壬辛", "身强"); // 壬+辛：身强（生我。辛生壬→金生水）
            put("壬壬", "身强"); // 壬+壬：身强（同我。壬同壬→水同水）
            put("壬癸", "身强"); // 壬+癸：身强（同我。壬同癸→水同水）
            put("壬子", "身强"); // 壬+子：身强（同我。壬同子→水同水）
            put("壬丑", "身弱"); // 壬+丑：身弱（克我。丑克壬→土克水）
            put("壬寅", "身弱"); // 壬+寅：身弱（我生。寅生壬→水生木）
            put("壬卯", "身弱"); // 壬+卯：身弱（我生。卯生壬→水生木）
            put("壬辰", "身弱"); // 壬+辰：身弱（克我。辰克壬→土克水）
            put("壬巳", "身弱"); // 壬+巳：身弱（我克。壬克巳→水克火）
            put("壬午", "身弱"); // 壬+午：身弱（我克。壬克午→水克火）
            put("壬未", "身弱"); // 壬+未：身弱（克我。未克壬→土克水）
            put("壬申", "身强"); // 壬+申：身强（生我。申生壬→金生水）
            put("壬酉", "身强"); // 壬+酉：身强（生我。酉生壬→金生水）
            put("壬戌", "身弱"); // 壬+戌：身弱（克我。戌克壬→土克水）
            put("壬亥", "身强"); // 壬+亥：身强（同我。壬同亥→水同水）
            put("癸甲", "身弱"); // 癸+甲：身弱（我生。癸生甲→水生木）
            put("癸乙", "身弱"); // 癸+乙：身弱（我生。癸生乙→水生木）
            put("癸丙", "身弱"); // 癸+丙：身弱（我克。癸克丙→水克火）
            put("癸丁", "身弱"); // 癸+丁：身弱（我克。癸克丁→水克火）
            put("癸戊", "身弱"); // 癸+戊：身弱（克我。戊克癸→土克水）
            put("癸己", "身弱"); // 癸+己：身弱（克我。己克癸→土克水）
            put("癸庚", "身强"); // 癸+庚：身强（生我。庚生癸→金生水）
            put("癸辛", "身强"); // 癸+辛：身强（生我。辛生癸→金生水）
            put("癸壬", "身强"); // 癸+壬：身强（同我。癸同壬→水同水）
            put("癸癸", "身强"); // 癸+癸：身强（同我。癸同癸→水同水）
            put("癸子", "身强"); // 癸+子：身强（同我。癸同子→水同水）
            put("癸丑", "身弱"); // 癸+丑：身弱（克我。丑克癸→土克水）
            put("癸寅", "身弱"); // 癸+寅：身弱（我生。寅生癸→水生木）
            put("癸卯", "身弱"); // 癸+卯：身弱（我生。卯生癸→水生木）
            put("癸辰", "身弱"); // 癸+辰：身弱（克我。辰克癸→土克水）
            put("癸巳", "身弱"); // 癸+巳：身弱（我克。癸克巳→水克火）
            put("癸午", "身弱"); // 癸+午：身弱（我克。癸克午→水克火）
            put("癸未", "身弱"); // 癸+未：身弱（克我。未克癸→土克水）
            put("癸申", "身强"); // 癸+申：身强（生我。申生癸→金生水）
            put("癸酉", "身强"); // 癸+酉：身强（生我。酉生癸→金生水）
            put("癸戌", "身弱"); // 癸+戌：身弱（克我。戌克癸→土克水）
            put("癸亥", "身强"); // 癸+亥：身强（同我。癸同亥→水同水）
        }
    };

    /**
     * 具体法获取喜用神（天干+季节为键）
     */
    public static final Map<String, List<String>> XI_YONG_SHEN = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            1、日干是'甲'或者'乙'：春天出生，以火土金为喜用神；夏天出生，以水木为喜用神；秋天出生，以水木为喜用神；冬天出生，以火金为喜用神；生于四季末，以水土为喜用神。
        　　2、日干是'丙'或者'丁'：春天出生，以水土为喜用神；夏天出生，以金水为喜用神；秋天出生，以木火为喜用神；冬天出生，以木火土为喜用神；生于四季末，以木火金为喜用神。
        　　3、日干是'戊'或者'己'：春天出生，以火土为喜用神；夏天出生，以金水木为喜用神；秋天出生，以火土为喜用神；冬天出生，以火土为喜用神；生于四季末，以木金水为喜用神。
        　　4、日干是'庚'或者'辛'：春天出生，以土金为喜用神；夏天出生，以土水金为喜用神；秋天出生，以火木水为喜用神；冬天出生，以火土金为喜用神；生于四季末，以水木火为喜用神。
        　　5、日干是'壬'或者'癸'：春天出生，以金水为喜用神；夏天出生，以金水为喜用神；秋天出生，以木火土为喜用神；冬天出生，以木火土为喜用神；生于四季末，以金水为喜用神。

            ☞ 注：四季月一般为农历三月、六月、九月、十二月。
         */ {
            put("甲春", Arrays.asList("火", "土", "金"));
            put("甲夏", Arrays.asList("水", "木"));
            put("甲秋", Arrays.asList("水", "木"));
            put("甲冬", Arrays.asList("火", "金"));
            put("甲四季末", Arrays.asList("水", "土"));
            put("乙春", Arrays.asList("火", "土", "金"));
            put("乙夏", Arrays.asList("水", "木"));
            put("乙秋", Arrays.asList("水", "木"));
            put("乙冬", Arrays.asList("火", "金"));
            put("乙四季末", Arrays.asList("水", "土"));
            put("丙春", Arrays.asList("水", "土"));
            put("丙夏", Arrays.asList("金", "水"));
            put("丙秋", Arrays.asList("木", "火"));
            put("丙冬", Arrays.asList("木", "火", "土"));
            put("丙四季末", Arrays.asList("木", "火", "金"));
            put("丁春", Arrays.asList("水", "土"));
            put("丁夏", Arrays.asList("金", "水"));
            put("丁秋", Arrays.asList("木", "火"));
            put("丁冬", Arrays.asList("木", "火", "土"));
            put("丁四季末", Arrays.asList("木", "火", "金"));
            put("戊春", Arrays.asList("火", "土"));
            put("戊夏", Arrays.asList("金", "水", "木"));
            put("戊秋", Arrays.asList("火", "土"));
            put("戊冬", Arrays.asList("火", "土"));
            put("戊四季末", Arrays.asList("木", "金", "水"));
            put("己春", Arrays.asList("火", "土"));
            put("己夏", Arrays.asList("金", "水", "木"));
            put("己秋", Arrays.asList("火", "土"));
            put("己冬", Arrays.asList("火", "土"));
            put("己四季末", Arrays.asList("木", "金", "水"));
            put("庚春", Arrays.asList("土", "金"));
            put("庚夏", Arrays.asList("土", "水", "金"));
            put("庚秋", Arrays.asList("火", "木", "水"));
            put("庚冬", Arrays.asList("火", "土", "金"));
            put("庚四季末", Arrays.asList("水", "木", "火"));
            put("辛春", Arrays.asList("土", "金"));
            put("辛夏", Arrays.asList("土", "水", "金"));
            put("辛秋", Arrays.asList("火", "木", "水"));
            put("辛冬", Arrays.asList("火", "土", "金"));
            put("辛四季末", Arrays.asList("水", "木", "火"));
            put("壬春", Arrays.asList("金", "水"));
            put("壬夏", Arrays.asList("金", "水"));
            put("壬秋", Arrays.asList("木", "火", "土"));
            put("壬冬", Arrays.asList("木", "火", "土"));
            put("壬四季末", Arrays.asList("金", "水"));
            put("癸春", Arrays.asList("金", "水"));
            put("癸夏", Arrays.asList("金", "水"));
            put("癸秋", Arrays.asList("木", "火", "土"));
            put("癸冬", Arrays.asList("木", "火", "土"));
            put("癸四季末", Arrays.asList("金", "水"));
        }
    };

    /**
     * 五行对应方位
     */
    public static final Map<String, List<String>> WU_XING_FANG_WEI = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        {
            put("木", Arrays.asList("东", "东南"));     // 木：东、东南
            put("火", Collections.singletonList("南")); // 火：南
            put("土", Arrays.asList("西南", "东北"));   // 土：西南、东北
            put("金", Arrays.asList("西", "西北"));     // 金：西、西北
            put("水", Collections.singletonList("北")); // 水：北
        }
    };

    /**
     * 五行旺衰（按月支判断）
     */
    public static final Map<String, List<String>> WU_XING_WANG_SHUAI = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        {
            put("子", Arrays.asList("水旺", "木相", "金休", "土囚", "火死"));
            put("丑", Arrays.asList("土旺", "金相", "火休", "木囚", "水死"));
            put("寅", Arrays.asList("木旺", "火相", "水休", "金囚", "土死"));
            put("卯", Arrays.asList("木旺", "火相", "水休", "金囚", "土死"));
            put("辰", Arrays.asList("土旺", "金相", "火休", "木囚", "水死"));
            put("巳", Arrays.asList("火旺", "土相", "木休", "水囚", "金死"));
            put("午", Arrays.asList("火旺", "土相", "木休", "水囚", "金死"));
            put("未", Arrays.asList("土旺", "金相", "火休", "木囚", "水死"));
            put("申", Arrays.asList("金旺", "水相", "土休", "火囚", "木死"));
            put("酉", Arrays.asList("金旺", "水相", "土休", "火囚", "木死"));
            put("戌", Arrays.asList("土旺", "金相", "火休", "木囚", "水死"));
            put("亥", Arrays.asList("水旺", "木相", "金休", "土囚", "火死"));
        }
    };

    /**
     * 命卦
     */
    public static final Map<Integer, List<String>> MING_GUA = new HashMap<Integer, List<String>>() {
        private static final long serialVersionUID = -1;

        {
            put(1, Arrays.asList("坎卦", "东四命", "一白坎水贪狼星", "北斗第一星。紫微斗数，甲级主星。北斗天枢，智星吉星。象征强有力的统治管理。主欲望，为人多外向感性，情感极为浓烈，对爱情的要求很强烈；生活中多表现为多才多艺、有表演欲、风趣幽默、受异性欢迎的类型；感情方面对另一半有强烈的不安全感，自我防卫心强，越爱对方，越想掌控，冲突越大，因此容易一言不和突然分手。性格灵敏机巧，善于交际，喜欢认识朋友，人缘很好，常得异性助力。但态度有点随性，肢体语言过当，有时会被误认为随便、轻佻。不喜欢平淡的爱情，贪欢享受，欲望强烈，婚姻很难和谐，尤其女性更为辛苦。因在传统价值观下，不论男女都很难接受另一半的好人缘与多应酬。但男性的风流，可以用事业上的逢场作戏来当借口，女性则会被视为“花痴”、难受公婆喜欢。贪多骛得，自我强烈，喜欢享受被多人簇拥的感觉，爱情上易爆发多角纠纷。")); // 一白坎水贪狼星
            put(2, Arrays.asList("坤卦", "西四命", "二黑坤土巨门星", "北斗第二星。吉星，爱恨分明。思维活跃，直具辩才。主口才好，个性耿直，直言不讳，爱恨分明。多适合以口为主的职业。为人多心思细密，耿直明快，理解力强，善于处公共关系。随风转舵，见人说话，比较符合传统价值观。分析力与联想力出色，直具辩才。但在性格的反面，又有不安于现状，性格较为顽固，自信，猜疑心强，不大相信别人，凡事都要打破砂锅问到底的隐忧，喜欢自己通过实践而出真知。感觉较严肃，话出如风，舌利如刀，易招口舌是非，言语直截了当，往往容易得罪人。也容易恃才傲物，不能服人，逞口舌之快。刀子嘴，豆腐心；人际关系常常过犹不及。这是古来论命，称巨门星“化暗”、恃才傲物，不易服人。主口舌纠纷的原因。好在辛劳奋斗后方能有成就可言。巨门的另一个主要特质是个性多疑。多疑不是坏事，因为人性如果不多疑，就会鲁莽。")); // 二黑坤土巨门星
            put(3, Arrays.asList("震卦", "东四命", "三碧震木禄存星", "北斗第三星。大吉星，十二宫中皆为福论，并有解厄制化之功。禄存星不入辰、戌、丑、未四墓宫，免除天罗地网的限制，主人一生运势甚平顺，波折较小。禄存星又名天禄星，为原财星，化气为富贵，主天禄。顾名思义，禄存星是既能得到“禄”，又可获得积“存”，关系着人一生的荣华富贵，是最标准的财星。主自信心，工作能稳扎稳打，不疾不徐，专注安定，保守拘谨，可独善己身，独立性强，凡事多靠自己打拼，不依赖别人，不强求埋怨，能获得重任。具有节制、储蓄、稳固性质，积德之财。有德者财源不绝，无德者劳碌挣财。禄存为羊陀所夹，亦代表要赚取钱财，必同时带有是非与劳累；内心常感孤寂，常为保守吝啬守财奴，不懂享受财富乐趣，从事管理钱财或货物可趋吉避凶。禄存星前后二邻宫有擎羊、陀罗双煞星相夹纹，以保护天禄，使得禄存星必须瞻前顾后，前冲后扯，行事因而保守稳重，宽厚节约，往往在富有之后，容易遭人嫉妒排挤，并产生纠纷，对此须多加注意。")); // 三碧震木禄存星
            put(4, Arrays.asList("巽卦", "东四命", "四绿巽木文曲星", "北斗第四星。天权伐星，管科甲名声、文墨官场、功名文雅。文曲与文昌同样是聪明才智的象征，文昌偏重于刀笔功名、典章制度、文喜契据方面，较属于经世致用的理性学术追求；文曲则偏重于诗词歌赋、琴棋书画等方面的才艺研讨，较属于生活情趣的感性内涵充实。儒雅浪暖，对喜爱的学术较为感性，俊雅磊落、口才便佞是文曲的特性。主在文学艺术方面较有天赋；对怡情养性方面的学术，较有用心投入的意愿和兴趣。诗书满腹，心性灵巧，手足多能，具备良好的天分及悟性，是为少年勤奋有功名利禄之格。学术上较易有良好的表现。像是文艺中的琴曲、书画等多须靠美感赢得世人的肯定，所以靠文曲的模仿能力，很容易能学习到这类美的感受，进而展现其成果。艺术方面，有擅长艺术的特点，对于文艺，音乐或者绘画等方面享有天赋。也有优异的记忆能力，只是这种的优秀能力多是用在感受的记忆上，不似文昌是用在实质可见的文字图象记忆。且因为文曲很容易记忆情境与感受，所以文曲会极易触景生情而有了强说愁的现象，让人觉得多愁善感。")); // 四绿巽木文曲星
            put(5, Arrays.asList("中卦", "", "五黄中土廉贞星", "北斗第五星。化气为囚，桃花畅旺。是非分明，敢做敢当。廉贞星与北斗第一星贪狼星被并称为“廉贞贪狼两大桃花”；其中桃花级别都是甲级星系；贪狼为正，廉贞则为偏，一阴一阳；廉贞为隐性的星系，主桃花非常旺。但它同样是一颗让人捉摸不透的星系，有着反复多变的性格预示。主人负责尽职，见识不凡，思想新颖，是非分明，敢做敢当，积极进取。从阴面来说，又主人心高气傲，情绪多变，自视过高，一意孤行，锋芒太露，逞强好胜，要求过严，心狂性暴。“自古廉贞最难辨”就是指的古人对于这颗星非常难以理解。且廉贞星古书称之为“杀星”与“囚星”。此星入命，心高气傲，个性冲动，所以行事常带邪气。但这个“邪”，是不信邪，是只要我喜欢，有什么不可以的我行我素，宁可闯得头破血流，也绝对相信自己，爱与恨都很容易走极端。傲气凌人，有优越感，有施舍对方、下嫁（娶）的感觉。一旦对方强过自己，会在心理上抗拒，自我防卫心很强。因此常造成爱情上的两难；对方不强不爱，对方太强也不爱，择偶的弹性很低，常会有高不成低不就的感慨。因为个人意识太强，常常否定社会主流价值观或道德观，容易走偏锋，在古时候是非常不讨喜的一颗星，但是在多元价值观的现代，廉贞的高行动力及意志力就很有发挥的空间，需要加强的则是耐力及情绪的控制，自然容易有所表现。")); // 五黄中土廉贞星
            put(6, Arrays.asList("乾卦", "西四命", "六白乾金武曲星", "北斗第六星。化气为财，财帛宫主。司掌财富、武勇，主财旺。武曲刚直坚韧，毅力惊人，是十四颗主星中之最。主刚毅果决，自立自强，吃苦耐劳，勇于任事，不畏挫折，负责尽职。武曲勇于任事，不畏挫折，身先士卒，同甘共苦，严肃刚直，不怒而威，让人不易亲近。当部属时，倔强固执，待人欠缺圆通，不会争功诿过，默默做事，对拍马逢迎颇为不屑，也因此不易受到赏识，换句话说，贵人运势较弱，这也是为何少年不易发达的原因。但当上领导者后，发挥天赋领导能力的武曲，则常能一鸣惊人，一飞冲天。只是太过理性，不重人和的结果，或是太过追逐名利，满身铜臭；处事略嫌严苛，自我要求过高，权力欲望太大。或是刚愎孤直，仇人比朋友多，中晚年后，孤独难免。举手投足之间，少了紫微、天府的帝王之气，却又比天相沉稳。眼神坚毅慈和，声调有力，动作敏捷，活动力强，凡事操心，重视秩序整洁，举止沉稳威严。")); // 六白乾金武曲星
            put(7, Arrays.asList("兑卦", "西四命", "七赤兑金破军星", "北斗第七星。化气为耗，司夫妻子女、领导管理。破军星古书称之为“耗星”。这个“耗”，代表破坏力、消耗力。在十四颗主星之中，个性最冲动，变化性最强。由于破军具备“耗”的特性，人生自然变化多端，成败难论。和七杀坐命的人一样，我行我素，喜新厌旧，个性倔强，反抗心重，不易合作，欠缺弹性，遇事每多辩驳，翻脸六亲不认。颇难管理。近朱者赤，近墨者黑，碰到不好的朋友或主管，很容易变坏；但是碰到好的朋友或主管，则常能发挥所长，身体力行，求新求变，吃苦耐劳，勇于任事，不畏横暴，善恶分明，反应迅捷，坦白直率。破军带有强烈的傲气，对自己非常有自信，落在夫妻宫里，代表此人对爱情期望很高，对感情的要求很强烈。爱上一个人的结果，就会完全投入，可是投入越深，得到的失望可能会越大。由于优越感作祟，廉贞会用“爱”做理由，对另一半颐指气使；用“我会让你更好”当借口，来不断要求对方。如果对方做不到，破军星又难以妥协，由于自信太强，反而很难抽身，无法接受分手，强烈的话，可能演变成极端的报复行动。爱情因此而消逝。破军适合坐落在事业宫，其主做事态度认真，一丝不苟，外柔内刚，又喜欢交朋友，初与人接触时，很容易从生变熟；但变熟之后，也会因一言不和，不遂己意而产生冲突，让外人以为他们人际关系复杂多变，对此也得多加注意。")); // 七赤兑金破军星
            put(8, Arrays.asList("艮卦", "西四命", "八白艮土左辅星", "北斗第八星。匡扶紫微，辅助天府。贵人辅佐，辅助善星。左辅星入命宫，主人面目清秀端正，面色黄白，稳重慷慨，大多随和，有上进心、有抱负。为人厚道，仁慈耿直，随和大方，心怀宽恕，有容人之量。做事颇有条理，稳健谨慎，计划性强。性好助人，乐善好施，信义卓著，一生亦多贵人扶持，并得异性之助力尤多。左辅星、右弼星的特性：左辅、右弼又称贵人星，辅佐(辅助)星。此处的贵人是属于同辈，而且是双向的，辅、弼都有〝帮助〞之意；亦即你帮助了别人也会得到别人的帮助。二颗星皆主〝善〞。")); // 八白艮土左辅星
            put(9, Arrays.asList("离卦", "东四命", "九紫离火右弼星", "北斗第九星。北斗之助，在数为善。右弼之宿，号为吉庆。其色紫红，性最燥，吉者遇之立刻发福，凶者值之勃然大祸，故术数家称为赶煞催贵之神，但火性刚不能容邪，宜吉不宜凶。主精晓文墨，文采风骚，个性娩转，好善乐施，亲和力佳。能提升个人的良善的本质。女命贤淑端庄善解人意，遇事能够往好的方面想，也能够多行好事，和谐善良，乐于助人，只是冲劲少了些。而右弼又较左辅多了些不受约束的本质，也所以多了些异性桃花缘。特征为平和宽容，可能让企图心少了些，要获致成功，则须多加些冲劲才行。多了些不受约束的本质，有时会有稍微偏差的行为出现，甚至有桃花纠纷，则是要留意的地方。")); // 九紫离火右弼星
        }
    };

//----------------------------------------------------------------------------------------------------------------------------------------------------

    /**
     * 日柱论命（日柱为键）
     */
    public static final Map<String, String> DAY_ZHU_LUN_MING = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("甲子", "多学少成，防止有始无终；心性暴躁，幼年多灾。重拜父母，饮食保养；兄弟骨肉少靠，有子多刑。男人妻大，女人夫长；伶俐聪明贤能；受人尊重，人际关系需权衡得当。");
            put("乙丑", "慷慨大方，喜爱春风，多学少成，幼年现灾，父母重拜；九流中人，夫妻无刑，儿女不孤，六亲少靠；女人贤良纯和，但求财心切，要关照家庭。");
            put("丙寅", "多学少成，心性不定；口快舌硬，身闲心直，手足不停，利官近贵，女人贤良，聪明伶俐，辛勤收获。");
            put("丁卯", "手足不停，身心不闲，内外有劳，衣禄不少，性巧聪明，做事有头少尾，男人福份之命，女人企图宁静，操劳中有幸而获，防不知足。");
            put("戊辰", "喜气春风，利官近贵，骨肉刑伤，儿女不孤，女人温良贤达，有口无心，乌鸦嘴豆腐心，主招好夫，需防止他人误会。");
            put("己巳", "聪明才智，手足伶俐，小有功名，做事如意；夫妻和睦相处，诸事可为；女人衣食住行不缺，善良待人；男人多出风头，小有计谋，资性英敏，福厚之命。");
            put("庚午", "口快心直，利官近贵，小有殊荣，衣禄丰盈。男人权柄，辛勤持家，外面固执，有人钦佩；女人秀气，略显美感，荣夫益子，邻里钦佩。");
            put("辛未", "生有志气，心性宽容尚仁义，少年灾病；中年略好，头胎见女更吉，生男有刑克；夫妻和睦相处，事业顺利；女人持家方兴旺，男人顾家多利业。");
            put("壬申", "性巧聪明，才智少显，计谋多变，诚信待人接物功名有份；有贤妻子，为人英敏，受人喜欢；女人美丽，博得人助！阶段富贵，荣华自珍！福气子孙。");
            put("癸酉", "心直公平，伶牙俐齿，防言多失；衣禄自俭，有备无患，平稳足用；六亲冷淡，自谋求生；社会交往，多有人爱，虽事不成，少取勿贪，百业可为；女人助夫，勤俭持家，晚年享福。");
            put("甲戌", "口快舌伶，身闲心不空，少年贫民，中年奔波，略有权职，心机谋略，多学少成，小有名声；晚景福禄延年，自珍自爱益寿；助人惹怨，妒嫉常伴随而来。");
            put("乙亥", "为人和顺，幼年多灾，父母有刑，诚实待人接物，出外稍好；女人夫好，和睦相处、偕老，存心中正，中年财旺，防劳致病；婚迟子晚，子女防克，重拜义母，严教成才。");
            put("丙子", "胆大言广，有权谋，心机诡诈，早年平平，中年成就，晚景大好，女人饶舌，言多有失，安分守己，避免麻烦，福气自到。");
            put("丁丑", "为人和睦，衣禄不愁，初年有旺禄常在，晚景大好，更有结余，婚迟子晚，夫妻和睦相处，则百事顺利。女人旺夫爱子，孝敬，持家贤良。");
            put("戊寅", "性格猛烈，刚强招祸，易快易冷，交往闲杂，小人无情；早年勤俭，离祖发达，聪明才智，手足伶俐；晚年大有良机，不可莽撞，得安宁，有幸福。");
            put("己卯", "为人交往广泛，风流倜倘、豪杰，衣禄丰足，闲情逸致，嬉戏娱乐，有人遵从；六亲冷淡，自立为上，骨肉难为，妻招年长，配偶和睦；女人注意邻居关系，自我解脱，旷达胸怀，长寿，亲族贤达。");
            put("庚辰", "春风和气，劳禄霜雪一生，利官近贵，名利双全，衣食足用；中年平顺，晚年大兴，女人勤俭，持家有方，受人敬仰，坎坷风波。个别命运身体衰弱，注意健康，追求安全的人生。");
            put("辛巳", "友善机谋，能应变，志气过人，衣食足用；有贵人扶助，中年和顺，老有福运，心安理得，知足常乐，有长寿命。");
            put("壬午", "为人勤俭，父母刑伤，早年财物不顺利，存储不多，中年劳心，稍有所得，晚景旺子，事应积蓄，防备缺乏。女人兴家，贤能自达，恒心有获。");
            put("癸未", "心急口快，为人伶俐；救人无恩，反招是非，曲直难辩，多有误会。有财无库，过眼烟云，财来财去，精打细算，可免祸灾；女人贤慧，勤俭持家；晚景平安。");
            put("甲申", "衣禄不少，心性温柔，出入有为，技压群芳，初年不顺，中年劳神，晚景利达；夫妻和顺，儿女迟到，女人操劳，忍耐莫逆，家事平安。");
            put("乙酉", "口快心直，轩昂大方，乐观，衣禄足用，兄弟虽有，难为助力；与人为善，事业成功；女人兴旺，小有蓄财，平稳，追寻安康生活。");
            put("丙戌", "性情温和，技艺护身，衣禄不愁，豪杰和顺，自能有财；独立家业；前运不周，利益不顺，中年操劳，钱财有进；晚年荣华。女人中年奔波，辛苦求财，老年稍微聚财发旺，珍惜为盼。");
            put("丁亥", "性巧聪明，小有才智；独立自营，奔波操劳，儿女有利，见迟方好；好为善事，稍微旺财；女人贞节自爱，得贵人帮助，幸有财运，衣禄平稳。");
            put("戊子", "计算聪明，才智有余，文武两通，儿女早产防克；结婚当晚，财运良好，运气颇佳，用情不专，家花、野花，警慎为佳！女人自珍，贤慧发福。");
            put("己丑", "口快心直，通技艺人，能掌实权，诚意待人，博得众望，衣禄不少；男人防再娶，家庭当和睦相处，女人晚年发福。");
            put("庚寅", "心性急快，有口无心，大事有藏；易好易怒，性情反复无常，伤人还不知道；易结人缘，也易失人缘，衣禄足用；早年不聚财物，中年奔波，晚景丰隆，女人内助，理事发达，勤俭有得。");
            put("辛卯", "口快心直，有志气，有权柄，利官近贵，身闲心不空；六亲少靠，自立家业，少年劳禄，晚年大利；女人持家，操劳，勤俭节约可兴隆。");
            put("壬辰", "劳禄之人，手脚停不下来；早年难守，财来财去，晚景发达。女人操家，勤奋兴旺。");
            put("癸巳", "聪明伶俐，近贵人，中年风霜，春风之徒；慎重守护已成之事业，可暂发福；好心对人，却被人反目，晚景渐佳。");
            put("甲午", "为人和气，好娱乐；青春好风荡，交往朋友，利官近贵，逢凶化吉，骨肉少靠。女人口快，心直能言；爱情上需防祸不单行。");
            put("乙未", "少年勤俭，初年平顺；兄弟少靠；子息不孤；晚年聚财，可以兴旺；女人持家，恩夫旺子，精打细算。");
            put("丙申", "衣食丰足，利路亨通，技能生财；早年劳禄，女人持家，勤俭节约，旺相发达。");
            put("丁酉", "喜好面子，多情重恩，缘份奇特；利官近贵，初年劳累，身闲心苦。晚年兴隆，子女有为；女人清秀吉昌，半夫半财，自立成功。");
            put("戊戌", "为人和气，独立自营；早年颠倒运程，是非耗财；中年贪求，欲望高昂，遭人妒嫉。自重；苦学技艺，学有工夫之命。女人育养，中平之命运。");
            put("己亥", "计巧伶俐，衣食安稳，骨肉少力，六亲冷淡，儿女早见刑克，迟到稍好；夫妻和顺。女人清闲，晚景顺遂。");
            put("庚子", "持重，安稳，衣禄无亏，妻子贤慧，持家有方，建交贵人，提拔机遇，逢凶化吉。女人兴旺，福荫家庭。");
            put("辛丑", "心性温和，早年须防惊恐，意外之厄；虽有衣禄，骨肉少力，晚年好，女人旺家，事多发达。");
            put("壬寅", "为人口快心直，男女都不能早结婚，若早婚夫妻便相克。儿女宜迟，初年颠倒，中年兴旺。女人如意，发福之命。");
            put("癸卯", "衣食不少，凶中化吉，早年不顺，财来财去，晚年好。女人操持之命，遭遇妒嫉，好事难全，少年弱，中年劳禄，老有欢乐。");
            put("甲辰", "衣食丰足，清闲心情；早年弱，中年勤奋，情感有波折，事业发达，晚结婚，子女宜迟，帮助多。");
            put("乙巳", "为人好面子，救人无功；好事莫望；早年子女刑克，晚年安宁。女人助夫爱子。");
            put("丙午", "身闲心不空，初年耗财，宜做基础，技能工夫，求名不利，事多争端，兄弟各方。女人清秀，思维奇妙。");
            put("丁未", "喜怒无常，口舌能言，名利不缺，骨肉疏远，子息迟到；衣禄丰足；女人有旺运，勤俭能兴家。");
            put("戊申", "为人性急，易反复无常；一生劳禄，利官见贵，儿女刑伤，财库富足，女人有旺运，勤俭能兴家。");
            put("己酉", "为人聪明，衣禄丰足，六亲少靠，儿女早见；凡事宽量，百事通达，女人技巧多变，少灾之命。");
            put("庚戌", "为人快活，丑未防灾；利官近贵，敏捷聪明，福气晚年，救人无义；女人心贤，勤奋方能兴家。");
            put("辛亥", "不惹闲事，清静守中；早年不聚财，晚景荣华富贵。女人勤俭，福丰，助立家业。");
            put("壬子", "幼年显灾，中年衣食丰足，男有好妻，身闲心劳，多喜多忧，奔波事业；兄弟少力，六亲冷淡，勤奋自立；女人贤能，提防嫉妒之心。");
            put("癸丑", "衣禄不少，一生得人尊重；莫惹是非，父母难为。骨肉少靠，夫妇和睦相处，顺利，儿女见迟；财物早年难聚，波折。");
            put("甲寅", "为人诚实，利官见贵。家道兴盛，父母有利，重拜双亲。男人怕妻，命硬三分。女人管夫，子息兴旺。");
            put("乙卯", "志气轩昂，衣禄丰足，计巧精妙，言行有诈，有成有败；文武两业，坎坷难免，金石为开，一事可成，女人福气，勤俭添寿。");
            put("丙辰", "聪明才智，手足伶俐，衣禄无亏；身闲心劳，爱交朋友，中年兴隆，女人贤能，勤俭建家。");
            put("丁巳", "为人刚强，利官近贵，个性乖巧，不易顺从；兄弟居长，事业显荣。女人贤慧，勤奋发达，热诚事业，防有头无尾，宜精益求精，专心致志，精打细算。");
            put("戊午", "为人温良，志气宽宏，衣禄丰足；少年多灾，骨肉有刑，夫妻显克；女人亲属少帮；中年勤奋，有收获；夫妻性格欠协调，影响健康，老可无忧，子女孝顺。");
            put("己未", "口快舌硬，衣禄小有，得贵人帮，勤奋敬业，精打细算，财源不绝。交往朋友，避免闲杂。");
            put("庚申", "手足不停，为人清高，利官近贵。夫妻口角，烦多爱少。做好事难得好报，救人无功，遭遇妒忌。女人兴家，六亲冷淡。");
            put("辛酉", "为人伶俐，面气清爽，艰辛创业，自谋高见，口舌能言，高人敬重，财力广大，六亲冷淡，骨肉情疏，女人贤达。");
            put("壬戌", "好行善事，四处不停，心劳尤多，衣食不缺，结交贵人，提拔事业，早年平，中年劳，晚年好;女人贤慧，操劳兴家。");
            put("癸亥", "为人刚直，言语坦然，不顺人情；六亲疏远，交往淡淡；自立家业，女人缘旺，家庭坎坷，诚信待人，慎重欺诈；多注意自身健康。");
        }
    };

    /**
     * 姻缘（日干支纳音+农历月份为键）
     */
    public static final Map<String, String> YIN_YUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("木1", "夫妻在年轻时就认识，二人心有灵犀，可惜中年过后，丈夫忍不住，见异思迁。");
            put("木2", "夫妻心连心，有长远的人生计划，喜欢互相比拼，晚年的时候，二人是富裕的。");
            put("木3", "在错误的选择下结了婚，婚后二人常常争吵，丈夫会在中年时候离开家庭，老来痛苦。");
            put("木4", "结婚过程中己有人出来相劝，可是男方花言巧语令女方下嫁，这段婚姻是为凶。");
            put("木5", "二人一生恩爱，少争吵，可惜缘份薄弱，常常分开两地，丈夫难以送自己最后一程。");
            put("木6", "丈夫必须年长十五岁或以上，夫妇有共同的兴趣，互相尊重，晚年二人死亡的差距不足五年。");
            put("木7", "离婚，夫妇成仇，子女成祸根，没有共同的心，大家都不愿维系这段婚姻。");
            put("木8", "孤独一人，即使结了婚，二人都常分离，而配偶年龄相进，会晚年丧偶。");
            put("木9", "夫妻二人年龄相若，可以平安步入晚年，老来互相照顾，一生无悔。");
            put("木10", "夫妻没有形克，二人幸福，有商有量，能够旺夫，结婚后可以白头，但丈夫赚钱不及妻子多。");
            put("木11", "丈夫脾气暴躁，没有忍耐，二十七岁前结婚的话将在三十岁后出现婚姻危机，二人难以白头。");
            put("木12", "夫妻可以白头到老（八字相冲的例外）二人互相照顾，没有家事烦恼，丈夫是中产人仕。");
            put("火1", "夫妻没有形克，二人幸福，有商有量，能够旺夫，结婚后可以白头，但丈夫赚钱不及妻子多。");
            put("火2", "丈夫脾气暴躁，没有忍耐，二十七岁前结婚的话将在三十岁后出现婚姻危机，二人难以白头。");
            put("火3", "夫妻可以白头到老（八字相冲的例外）二人互相照顾，没有家事烦恼，丈夫是中产人仕。");
            put("火4", "夫妻在年轻时就认识，二人心有灵犀，可惜中年过后，丈夫忍不住，见异思迁。");
            put("火5", "夫妻心连心，有长远的人生计划，喜欢互相比拼，晚年的时候，二人是富裕的。");
            put("火6", "在错误的选择下结了婚，婚后二人常常争吵，丈夫会在中年时候离开家庭，老来痛苦。");
            put("火7", "结婚过程中己有人出来相劝，可是男方花言巧语令女方下嫁，这段婚姻是为凶。");
            put("火8", "二人一生恩爱，少争吵，可惜缘份薄弱，常常分开两地，丈夫难以送自己最后一程。");
            put("火9", "丈夫必须年长十五岁或以上，夫妇有共同的兴趣，互相尊重，晚年二人死亡的差距不足五年。");
            put("火10", "离婚，夫妇成仇，子女成祸根，没有共同的心，大家都不愿维系这段婚姻。");
            put("火11", "孤独一人，即使结了婚，二人都常分离，而配偶年龄相进，会晚年丧偶。");
            put("火12", "夫妻二人年龄相若，可以平安步入晚年，老来互相照顾，一生无悔。");
            put("土1", "结婚过程中己有人出来相劝，可是男方花言巧语令女方下嫁，这段婚姻是为凶。");
            put("土2", "二人一生恩爱，少争吵，可惜缘份薄弱，常常分开两地，丈夫难以送自己最后一程。");
            put("土3", "丈夫必须年长十五岁或以上，夫妇有共同的兴趣，互相尊重，晚年二人死亡的差距不足五年。");
            put("土4", "离婚，夫妇成仇，子女成祸根，没有共同的心，大家都不愿维系这段婚姻。");
            put("土5", "孤独一人，即使结了婚，二人都常分离，而配偶年龄相进，会晚年丧偶。");
            put("土6", "夫妻二人年龄相若，可以平安步入晚年，老来互相照顾，一生无悔。");
            put("土7", "夫妻没有形克，二人幸福，有商有量，能够旺夫，结婚后可以白头，但丈夫赚钱不及妻子多。");
            put("土8", "丈夫脾气暴躁，没有忍耐，二十七岁前结婚的话将在三十岁后出现婚姻危机，二人难以白头。");
            put("土9", "夫妻可以白头到老（八字相冲的例外）二人互相照顾，没有家事烦恼，丈夫是中产人仕。");
            put("土10", "夫妻在年轻时就认识，二人心有灵犀，可惜中年过后，丈夫忍不住，见异思迁。");
            put("土11", "夫妻心连心，有长远的人生计划，喜欢互相比拼，晚年的时候，二人是富裕的。");
            put("土12", "在错误的选择下结了婚，婚后二人常常争吵，丈夫会在中年时候离开家庭，老来痛苦。");
            put("金1", "离婚，夫妇成仇，子女成祸根，没有共同的心，大家都不愿维系这段婚姻。");
            put("金2", "孤独一人，即使结了婚，二人都常分离，而配偶年龄相进，会晚年丧偶。");
            put("金3", "夫妻二人年龄相若，可以平安步入晚年，老来互相照顾，一生无悔。");
            put("金4", "夫妻没有形克，二人幸福，有商有量，能够旺夫，结婚后可以白头，但丈夫赚钱不及妻子多。");
            put("金5", "丈夫脾气暴躁，没有忍耐，二十七岁前结婚的话将在三十岁后出现婚姻危机，二人难以白头。");
            put("金6", "夫妻可以白头到老（八字相冲的例外）二人互相照顾，没有家事烦恼，丈夫是中产人仕。");
            put("金7", "夫妻在年轻时就认识，二人心有灵犀，可惜中年过后，丈夫忍不住，见异思迁。");
            put("金8", "夫妻心连心，有长远的人生计划，喜欢互相比拼，晚年的时候，二人是富裕的。");
            put("金9", "在错误的选择下结了婚，婚后二人常常争吵，丈夫会在中年时候离开家庭，老来痛苦。");
            put("金10", "结婚过程中己有人出来相劝，可是男方花言巧语令女方下嫁，这段婚姻是为凶。");
            put("金11", "二人一生恩爱，少争吵，可惜缘份薄弱，常常分开两地，丈夫难以送自己最后一程。");
            put("金12", "丈夫必须年长十五岁或以上，夫妇有共同的兴趣，互相尊重，晚年二人死亡的差距不足五年。");
            put("水1", "结婚过程中己有人出来相劝，可是男方花言巧语令女方下嫁，这段婚姻是为凶。");
            put("水2", "二人一生恩爱，少争吵，可惜缘份薄弱，常常分开两地，丈夫难以送自己最后一程。");
            put("水3", "丈夫必须年长十五岁或以上，夫妇有共同的兴趣，互相尊重，晚年二人死亡的差距不足五年。");
            put("水4", "离婚，夫妇成仇，子女成祸根，没有共同的心，大家都不愿维系这段婚姻。");
            put("水5", "孤独一人，即使结了婚，二人都常分离，而配偶年龄相进，会晚年丧偶。");
            put("水6", "夫妻二人年龄相若，可以平安步入晚年，老来互相照顾，一生无悔。");
            put("水7", "夫妻没有形克，二人幸福，有商有量，能够旺夫，结婚后可以白头，但丈夫赚钱不及妻子多。");
            put("水8", "丈夫脾气暴躁，没有忍耐，二十七岁前结婚的话将在三十岁后出现婚姻危机，二人难以白头。");
            put("水9", "夫妻可以白头到老（八字相冲的例外）二人互相照顾，没有家事烦恼，丈夫是中产人仕。");
            put("水10", "夫妻在年轻时就认识，二人心有灵犀，可惜中年过后，丈夫忍不住，见异思迁。");
            put("水11", "夫妻心连心，有长远的人生计划，喜欢互相比拼，晚年的时候，二人是富裕的。");
            put("水12", "在错误的选择下结了婚，婚后二人常常争吵，丈夫会在中年时候离开家庭，老来痛苦。");
        }
    };

    /**
     * 出生年骨重
     */
    public static final Map<String, Double> YEAR_GU_ZHONG = new HashMap<String, Double>() {
        private static final long serialVersionUID = -1;

        {
            put("甲子", 1.2); // 甲子年：一两二钱
            put("乙丑", 0.9); // 乙丑年：九钱
            put("丙寅", 0.6); // 丙寅年：六钱
            put("丁卯", 0.7); // 丁卯年：七钱
            put("戊辰", 1.2); // 戊辰年：一两二钱
            put("己已", 0.5); // 己已年：五钱
            put("庚午", 0.9); // 庚午年：九钱
            put("辛未", 0.8); // 辛未年：八钱
            put("壬申", 0.7); // 壬申年：七钱
            put("癸酉", 0.8); // 癸酉年：八钱
            put("甲戌", 1.5); // 甲戌年：一两五钱
            put("乙亥", 0.9); // 乙亥年：九钱
            put("丙子", 1.6); // 丙子年：一两六钱
            put("丁丑", 0.8); // 丁丑年：八钱
            put("戊寅", 0.8); // 戊寅年：八钱
            put("己卯", 1.9); // 己卯年：一两九钱
            put("庚辰", 1.2); // 庚辰年：一两二钱
            put("辛已", 1.6); // 辛已年：六钱
            put("壬午", 1.8); // 壬午年：八钱
            put("癸未", 0.7); // 癸未年：七钱
            put("甲申", 0.5); // 甲申年：五钱
            put("乙酉", 1.5); // 乙酉年：一两五钱
            put("丙戌", 0.6); // 丙戌年：六钱
            put("丁亥", 1.6); // 丁亥年：一两六钱
            put("戊子", 1.5); // 戊子年：一两五钱
            put("己丑", 0.7); // 己丑年：七钱
            put("庚寅", 0.9); // 庚寅年：九钱
            put("辛卯", 1.2); // 辛卯年：一两二钱
            put("壬辰", 1.0); // 壬辰年：一两
            put("癸已", 0.7); // 癸已年：七钱
            put("甲午", 1.5); // 甲午年：一两五钱
            put("乙未", 0.6); // 乙未年：六钱
            put("丙申", 0.5); // 丙申年：五钱
            put("丁酉", 1.4); // 丁酉年：一两四钱
            put("戊戌", 1.4); // 戊戌年：一两四钱
            put("己亥", 0.9); // 己亥年：九钱
            put("庚子", 0.7); // 庚子年：七钱
            put("辛丑", 0.7); // 辛丑年：七钱
            put("壬寅", 0.9); // 壬寅年：九钱
            put("癸卯", 1.2); // 癸卯年：一两二钱
            put("甲辰", 0.8); // 甲辰年：八钱
            put("乙已", 0.7); // 乙已年：七钱
            put("丙午", 1.3); // 丙午年：一两三钱
            put("丁未", 0.5); // 丁未年：五钱
            put("戊申", 1.4); // 戊申年：一两四钱
            put("己酉", 0.5); // 己酉年：五钱
            put("庚戌", 0.9); // 庚戌年：九钱
            put("辛亥", 1.7); // 辛亥年：一两七钱
            put("壬子", 0.5); // 壬子年：五钱
            put("癸丑", 0.7); // 癸丑年：七钱
            put("甲寅", 1.2); // 甲寅年：一两二钱
            put("乙卯", 0.8); // 乙卯年：八钱
            put("丙辰", 0.8); // 丙辰年：八钱
            put("丁已", 0.6); // 丁已年：六钱
            put("戊午", 1.9); // 戊午年：一两九钱
            put("己未", 0.6); // 己未年：六钱
            put("庚申", 0.8); // 庚申年：八钱
            put("辛酉", 1.6); // 辛酉年：一两六钱
            put("壬戌", 1.0); // 壬戌年：一两
            put("癸亥", 0.6); // 癸亥年：六钱
        }
    };

    /**
     * 出生月骨重
     */
    public static final Map<String, Double> MONTH_GU_ZHONG = new HashMap<String, Double>() {
        private static final long serialVersionUID = -1;

        {
            put("1", 0.6);  // 农历一月：六钱
            put("2", 0.7);  // 农历二月：七钱
            put("3", 1.8);  // 农历三月：一两八钱
            put("4", 0.9);  // 农历四月：九钱
            put("5", 0.5);  // 农历五月：五钱
            put("6", 1.6);  // 农历六月：一两六钱
            put("7", 0.9);  // 农历七月：九钱
            put("8", 1.5);  // 农历八月：一两五钱
            put("9", 1.8);  // 农历九月：一两八钱
            put("10", 0.8); // 农历十月：八钱
            put("11", 0.9); // 农历十一月：九钱
            put("12", 0.5); // 农历十二月：五钱
        }
    };

    /**
     * 出生日骨重
     */
    public static final Map<String, Double> DAY_GU_ZHONG = new HashMap<String, Double>() {
        private static final long serialVersionUID = -1;

        {
            put("1", 0.5);  // 初一：五钱
            put("2", 1.0);  // 初二：一两
            put("3", 0.8);  // 初三：八钱
            put("4", 1.5);  // 初四：一两五钱
            put("5", 1.6);  // 初五：一两六钱
            put("6", 1.5);  // 初六：一两五钱
            put("7", 0.8);  // 初七：八钱
            put("8", 1.6);  // 初八：一两六钱
            put("9", 0.8);  // 初九：八钱
            put("10", 1.6); // 初十：一两六钱
            put("11", 0.9); // 十一：九钱
            put("12", 1.7); // 十二：一两七钱
            put("13", 0.8); // 十三：八钱
            put("14", 0.7); // 十四：一两七钱
            put("15", 1.0); // 十五：一两
            put("16", 0.8); // 十六：八钱
            put("17", 0.9); // 十七：九钱
            put("18", 1.8); // 十八：一两八钱
            put("19", 0.5); // 十九：五钱
            put("20", 1.5); // 二十：一两五钱
            put("21", 1.0); // 二十一：一两
            put("22", 0.9); // 二十二：九钱
            put("23", 0.8); // 二十三：八钱
            put("24", 0.9); // 二十四：九钱
            put("25", 1.5); // 二十五：一两五钱
            put("26", 1.8); // 二十六：一两八钱
            put("27", 0.7); // 二十七：七钱
            put("28", 0.8); // 二十八：八钱
            put("29", 1.6); // 二十九：一两六钱
            put("30", 0.6); // 三十：六钱
        }
    };

    /**
     * 出生时辰骨重
     */
    public static final Map<String, Double> HOUR_GU_ZHONG = new HashMap<String, Double>() {
        private static final long serialVersionUID = -1;

        {
            put("子", 1.6); // 子时：一两六钱
            put("丑", 0.6); // 丑时：六钱
            put("寅", 0.7); // 寅时：七钱
            put("卯", 1.0); // 卯时：一两
            put("辰", 0.9); // 辰时：九钱
            put("已", 1.6); // 已时：一两六钱
            put("午", 1.0); // 午时：一两
            put("未", 0.8); // 未时：八钱
            put("申", 0.8); // 申时：八钱
            put("酉", 0.9); // 酉时：九钱
            put("戌", 0.6); // 戌时：六钱
            put("亥", 0.6); // 亥时：六钱
        }
    };

    /**
     * 骨重批注（男命运程）
     */
    public static final Map<Double, String> YUN_CHENG_WAN = new HashMap<Double, String>() {
        private static final long serialVersionUID = -1;

        {
            put(2.1, "身寒骨冷苦伶仃，此命推来行乞人，碌碌苦苦无乐日，终生孤单过一生。");
            put(2.2, "乞丐命，孤苦伶仃，朝不保夕，吃不饱穿不暖，为人庸碌无能，一生行乞度过。");
            put(2.3, "福气不全，求谋作事却一事难成，妻儿兄弟旨不可靠，离乡别井投靠别人，尚可有两餐温饱。");
            put(2.4, "福禄不全，出身贫苦，家道难有兴旺的一日，亲人没有助力，宜出外谋事，但求三餐一宿。");
            put(2.5, "祖荫少，出身贫苦，六亲无情冷漠，难以依靠，一生辛劳自食其力，尚且能得两餐温饱。");
            put(2.6, "苦中挣扎，独自为生活奔波劳碌，宜及早离家谋事，勤勤恳恳，晚年生活虽不富裕，但总算无忧。");
            put(2.7, "祖荫少，出身贫苦，少年已须靠自己到处闯，到处碰壁，多做少成，一生烦恼困苦无穷无尽。");
            put(2.8, "出身贫苦，父母或家庭没能大庇荫，一生辗转流离，飘泊无依，若无过继他人，便是一生居无定所。");
            put(2.9, "早年运差，诸事欠顺，四十岁后才可安身立命，名成利就，离乡别井或改姓对运程有帮助。");
            put(3.0, "一生劳碌奔波，为生计而苦苦挣扎，难有安定日子，须终身勤俭克苦，晚年才能稍有安稳。");
            put(3.1, "早年谋事艰苦，家道贫寒，为生计而苦苦挣扎，中年后才见顺利，兴家立业，衣食尚算无忧。");
            put(3.2, "早年运滞，诸事难成，后来渐有财源滚滚的一天，而中年后衣食不缺，名利双收。");
            put(3.3, "早年事事难成，半生辛劳谋事亦枉费心力，多做少成，至晚年运势稍旺，衣食无忧。");
            put(3.4, "在尘世福禄不全，为僧道之命，须离乡别井，终身拜佛修道，多作善事才得善果。");
            put(3.5, "福分不全，缺少家荫，谋事须安守本份，不可好高?远，待时来运到之时，自能衣食不缺。");
            put(3.6, "早年福星高照，际遇非凡，并非庸碌无能之人，福分不浅，能靠自己能力出人头地，诸事皆成。");
            put(3.7, "事事难成，兄弟缺乏助力，须自食其力，一生辛劳亦难守微不足道的祖业，枉费心力。");
            put(3.8, "骨格清高，聪明勤学，终能苦学成才，中年后有望摆脱贫苦，甚至踏足官场，或在大机构担任要职。");
            put(3.9, "终身运势不通，多劳少成，儘管一生苦心竭力，克勤克俭营生，即使略有所成，到头来还是无福享受。");
            put(4.0, "早年虽吃苦，但注定福禄绵长，早年受过不少风霜挫折，犹幸为人聪明能干，意志坚定，终能大器晚成。");
            put(4.1, "为人聪明能干，绝非池中物，早年运势欠顺，但中年运势转顺，已能无忧无虑，逍遥自在。");
            put(4.2, "早年运气不顺，为名利终日多思多虑，难以宽怀，中年后运势渐顺，名利齐来。");
            put(4.3, "心思灵巧，聪明能干，人品极佳，做事光明磊落，早注定衣禄丰厚，一生无须劳心劳神。");
            put(4.4, "早年过份强求名利，奈何财运不顺，但福份也是靠修来的，该放开胸怀，晚年便能无忧。");
            put(4.5, "早年为名利奔波劳碌，中年后亦难以安定，一生难有儿女，晚年运须靠早年未雨绸缪。");
            put(4.6, "父母没有能力庇荫，早年须离乡别井穿州过省谋事，改姓或过继他人运势更佳，中年后衣食丰足。");
            put(4.7, "福份绵长，无须为营生而终日劳碌，晚年运尤佳，妻 (夫) 荣子贵，生活无忧无虑，财源滚滚，丰衣足食。");
            put(4.8, "早运不佳，蹉跎岁月，辛苦奔波，多劳少成，命带孤苦，无依无靠，但晚年亦算兴隆，衣食丰足。");
            put(4.9, "福泽不浅，聪明自立，能靠双手光宗耀祖，白手兴家，晚年有名有利，有财有势，受人敬仰。");
            put(5.0, "为名利劳心劳力，难以安心，中年福禄亦不佳，但几番辛苦之后，晚年财星高照，衣食丰足。");
            put(5.1, "一生事事顺遂，无须劳心劳神，亲人皆有助力，一门显赫，立业兴家之时，福禄无穷。");
            put(5.2, "家世显赫，聪明有才干，一世亨通，事事顺利，无须劳苦奔波，自能光宗耀祖，家财万贯。");
            put(5.3, "福泽深厚，聪明有才干，一生衣食无忧，立业兴家，财源丰厚，富甲一方。");
            put(5.4, "福泽深厚，出身书香世代，饱读诗书，必能名成利就，丰衣足食，生活安稳，无忧无虑。");
            put(5.5, "才干非凡，从事武职(纪律部队)争名逐利，少年作事枉费心力，中年后富贵荣华，显耀六亲。");
            put(5.6, "人品非凡，胸怀磊落，早年尝过不少苦楚，但福禄无穷，财源滚滚，晚年丰足。");
            put(5.7, "福禄双全，富贵长寿，品德完美的圣人，名闻于世，受万人景仰，一生无忧无虑淡泊名利。");
            put(5.8, "富贵福禄俱全，衣食自来，饱读诗书，为高官厚禄之命，或在大机购中身居要职，执掌权柄。");
            put(5.9, "聪明灵巧，出类拔萃，饱读成才，在古代为状元之命，从事武职 (纪律部队) 功名显赫。");
            put(6.0, "聪明能干，饱读诗书，在古代必金榜提名，扬明立万，显耀宗亲，衣食不缺，田产家财丰盛。");
            put(6.1, "聪明能干，天才横溢，若非饱学成才，也必定富甲一方，成就非凡，举世闻名，光宗耀祖。");
            put(6.2, "福泽深厚，饱学成才，荣华富贵无穷无尽，在古代为卿相之命，威名显赫，在现今也可解作掌权。");
            put(6.3, "饱学成才，命格注定为官，或在大机购中掌权，福禄无穷，富贵荣华，家世兴旺，一门显赫。");
            put(6.4, "古代为上书之命，能掌权威，富贵不尽，功名显赫，在现今亦必为一国高官，政绩超凡。");
            put(6.5, "品格非凡，在古代为大将军之命，建功立业，威名显赫，在现今可解作从事武职而得威权。");
            put(6.6, "出身富裕之家，福气深厚，无须为名利烦恼，无忧无虑，亦可凭一己聪明而饱学成才。");
            put(6.7, "出身显赫富裕之家，福禄自然而至，家财冠世而声望高，富可敌国，衣食丰足，事事顺利。");
            put(6.8, "生于富裕之家，家财万贯，无须为名利愁烦，但才干不凡，能靠自己能力使家业更鼎盛。");
            put(6.9, "在古代为受封赐之命，在现代可以为官，亦可以是在大机购中受到赏识而掌权，富贵双全，受人钦仰。");
            put(7.0, "虽福份不轻，但终日劳心劳神，劳劳役役，追名逐利，其实注定富贵双全，位高权重，名闻四海。");
            put(7.1, "命格超凡，富贵双全，在古代为公侯卿相之命，成就非凡，位高权重之馀，却能无忧无虑。");
            put(7.2, "此格世界罕有生，十代积善产此人，天上紫微来照命，统治万民乐太平。");
        }
    };

    /**
     * 骨重批注（女命运程）
     */
    public static final Map<Double, String> YUN_CHENG_WOMAN = new HashMap<Double, String>() {
        private static final long serialVersionUID = -1;

        {
            put(2.1, "一生运势不是很顺利，但是还是有机会翻盘的。千万不要因为一时困顿就灰心丧志，如果能够敞开心怀，接受新的事物，坚信事情终会否极泰来。");
            put(2.2, "一生辛苦，但也只能解决基本的温饱问题，很难成就大事，而且还时常遭遇困境和灾祸。但也不能就此自暴自弃，这都是福报不够的表现。要多行善事，甘愿吃苦，自有苦尽甘来之日。");
            put(2.3, "孤独，苛刻，与六亲缘浅。对自己的帮助很少，只有自己辛苦地生活，到了中年会续弦再嫁逐渐转好。改变自己的性格，可多行善，一切都向好的方向发展。");
            put(2.4, "家庭背景并不能给她带来过多的好运和福气。婚姻也不是很幸福，丈夫对自己不是很上心，子女也对自己不孝顺。晚年生活，孤单困苦，没有依靠。");
            put(2.5, "一生总是非常操劳，也不是很顺遂，但一定要坚信努力过后会得到自己想要的生活。");
            put(2.6, "为人聪明、伶俐、善良、心灵手巧。早年六亲无靠，生活辛苦，尝尽人间百味，到了三十六至五十一岁离开家乡自立门户，晚年可保安定，衣食无忧，安然到老，但要注意身体健康方面。");
            put(2.7, "独立自主性很强，很多事情都不需要男人相助。婚姻注定有阻碍，不过就算如此，命主也能够靠自己安逸的度过晚年。");
            put(2.8, "天生八字轻，意味着身主天生就体质虚弱。身主善解人意，并且是不为人知，无私奉献。特别注意的是害人之心不可有，防人之心不可无。");
            put(2.9, "性格坚强、自我独立、有自信、稳健乐观，同时对于求财的态度也是适可而止。心态乐观向上，能够从生活中获得乐趣。");
            put(3.0, "命主财运不错，而且理财能力很强，尤其是结婚之后，更是家中赚钱能手，不过对另一半不是很满意。中年时期多困扰，坏运连连，不过只要命主不因一时困顿就灰心丧志，任何事情都会否极泰来。");
            put(3.1, "性格温柔和顺，心地善良，对父母表现出孝顺和关爱。早年时，生活经历辛劳奔波，需要靠自己的努力来维持生计。这段时期可能会面临一些困难和挑战，但是通过自给自足，逐渐建立起稳定的家庭。然而，在二十四岁至三十二岁期间，家运并不太顺利，可能会经历一些不安定的时期。然而，随着中年时期的到来，运势逐渐好转。就像枯树一样，在逆境中逐渐开出鲜花，生活逐渐变得如意。中年时期将会迎来一些机遇和成功的机会，事业和财运也会逐渐提升。通过勤劳致富，此命之人能够实现稳定的经济状况。晚年时，忧愁会逐渐散去，生活变得安稳且富足。通过一生的勤劳努力，没有遭受到大的灾难和不幸的打击。在婚姻方面，丈夫可能会年纪较大，但是两人关系和谐稳定，没有出现刑克的情况。");
            put(3.2, "天生有福星高照的人，一生都是福气满满的好命运。这类人生活中是很有福气的，就算碰上不顺利不吉利的事情也能逢凶化吉，并且比较有情义。此命为人性干强，初限顺事，性情柔和，人才貌出众，一生有福禄，中处二十八九渐有顺意，出外谋事骨肉弟妹相助，家顺事通百事如意，温存如至，春光花百发，微风细雨生。人到四十五岁左右会有一次运势大涨的阶段，财旺福旺人也旺，儿女子孙孝顺有能力有前途，晚年生活福禄双收。");
            put(3.3, "心巧人灵，善良待人，无心口直，恩中招怨，夫君争敬，姐妹妒嫉，骨肉少亲，夫君大配方可，前都平平，凡事须谨慎交接自然和。女命生来八字轻，末年交运随夫君，方有后发。");
            put(3.4, "好比矮矮的刺枣树，此种灌木难以成大树，有宗教缘分，适宜修行。性格急躁，心浮气盛，早年与人谋事不容易成功，辛苦奔波，需要自给自足，丈夫为生肖属猴、猪、羊、蛇不适宜，龙、虎、牛、马较为适宜，中年运势平平，晚年可保无忧，安闲自在。");
            put(3.5, "心性高顺，为人心直品行佳，为人办事总有小人之害，驳杂多端，六亲弟妹不能得力，薄兴甚是险，女子却难禁二十七，八三十岁，心事须小心，还至交运苦哀哉，好人总有好来报，四十岁上交好运，夫和子随家业兴起。");
            put(3.6, "生性单纯善良，品行极佳，非常孝顺。家业根基不牢固，但是八字命中有贵人相助。有帮夫相，婚后不仅能够创造一个温馨的家庭氛围，还能在事业上给老公带来好运气，晚年生活也是儿孙满堂、和谐美满。");
            put(3.7, "如果做出亏心事，精神受折磨，做事情之前最好多听听家人或朋友的提议，有安定的生活或是工作最好不要想出来。");
            put(3.8, "如凤凰在岐山鸣叫一样，名声扬四方，生活会大昌大吉，顺利而且富足。如果遇到不好的事情，如丈夫走失没有音讯，以后也会重新有音讯。");
            put(3.9, "运气差，不管怎么努力劳碌挣扎，像是被关在笼子里的鸟一样，不管怎么折腾都是白费力气，到了中年和老年的时候很凄凉，没有什么亲人在身边，孤独寂寞。");
            put(4.0, "目前命运不好，经历了许多困难和艰辛，遭受了很多痛苦和困难。随着年龄的增长，会有更多的福气和财富，这些财富可以在晚年享受。暗示着在努力工作和坚持生活的过程中，需要保持信念和希望，相信未来会更好。");
            put(4.1, "看起来只是一般的艰难，女子虽然是人却比人要厉害；中年的时候悠闲是多么自由，晚年的时候甚至比中年还要悠闲自由。");
            put(4.2, "本来运气不太好，新的活力和灵感从自身身上迸发出来，新的活力和能量有帮助到别人，就对人有好的影响，所以自身周围的人对自己的评价也会有很好的转变，中年的运气来到，有很好的好转，自己可安然对待。");
            put(4.3, "生性敏感、单纯善良，做事比较优柔寡断。但能够真诚的对待他人，做事本本分分，运气财运都是很不错的。");
            put(4.4, "为人性表柔和，心无所毒，早年成婚，自成自立，劳苦奔波，遇事有始有终，六亲父母都无靠月令不合，事做不关，凡事要耐，休要琢磨，初限画饼充饥，中年名利有望，东北遇佳音，后天赐一子送终。");
            put(4.5, "安分守己，遇事可行，六亲姊妹无靠，初限驳杂多端，门庭不顺，夫君白手成空，女子命从，三十四换家运，四十开外如行船遇顺风，方到五十才安稳，夫君能硬配。");
            put(4.6, "个性有点急躁，充满了正能量，身体健康。事业运势不错，总是能够很好的处理要做的事情，并且事情的发展完全达到自己预期的目标。早年时期可能够会遇到大大小小的不如意，但是在自己的勤奋之下，能够改变自己的运势。尤其是中年时期，事业爱情更是好的不得了。无论是生活上，还是做事方面一定要谨言慎行，切勿因小失大。");
            put(4.7, "为人做事公平，待人慈祥，走失可失俱，早限少国驳驳杂杂，只到三十六岁以上金菊遇秋花盛开，枯木逢春，末运交来方秋怀，夫君大配至五十九有一险。");
            put(4.8, "性格虽然急躁，但是做事大胆心细，随机应变能力很强。早年时期在外奔波忙碌，晚年会在自己的努力下，过上福寿安康的生活。事业心比较重。因此会在事业稳定之后，才会考虑到婚姻大事。不过这样的婚姻家庭也算是比较幸福稳定的。");
            put(4.9, "一生的福气都很好，还可以旺夫。不仅长得很美丽，有着很好的额容貌，也很得丈夫的宠爱。可以让丈夫也很有福气，两人一生财运都不错。");
            put(5.0, "一生平稳之人，性子锐意，命格起伏，一生峥嵘。中年有灾祸，晚年财星相伴。称骨批语，为利为名终日劳，中年福禄也多遭，老来是有财星照，不比前番目下高。自身极具人格魅力，出类拔萃，潜力惊人，从者云集。行为处事富有原则。一生峥嵘，胸怀天下，巾帼不让须眉，自幼家境殷实，青年之时终日奔波，重视利益，往来之人多为钱财。缺乏知心之人。");
            put(5.1, "为人心直口快，性情爽朗，慈善敬重双亲，喜交结朋友和姐妹，平生正直，凶险皆无，出门吉利行人到，是非口舌不相干，夫君见迟方可好，夫媳二招方得实，夫君到白头。");
            put(5.2, "不仅勤俭持家，心灵手巧，而且很会为人处事。无论走到哪里发展，只要自己肯努力，都能够拥有很好财运，收获很好的人缘。此命格的女性朋友，在中年时期会遇到人生的低谷期，如果能够顺利渡过，下半生必定是衣食无忧、吉祥安康。另外在决定婚姻大事的时候，一定要擦亮双眼，小心慎重。");
            put(5.3, "天真活泼、心地善良，而且谦虚谨慎、非常孝顺。不管是年轻的时候，还是晚年时期，命主的财运福气都很不错，一生能够安家乐业。有旺夫之相，如果夫妻之间能够和谐相处，也没有婚姻不合的地方。那么，命主不仅能够在事业上给另一半带来财运，还能够给子孙后代带来好的运气。");
            put(5.4, "生活上自强自立，事业上发奋图强，可以说各个方面的能力都很不错。表面上冷漠无情，实则善良孝顺。属于事业型女强人。感情方面，晚婚的可能性很大，但是冥冥之中自有天意，在外出求财期间，时机成熟了，自然会遇到那个有缘之人。");
            put(5.5, "非常有上进心、有志向。而想要出人头地，光宗耀祖，最好的方式就是离开家门，到外面去发展。而想要一个美满幸福的婚姻，首先是选择和自己志同道合、情投意合的另一半，然后两人最好是一起生活共事，尽量避免分居两地，导致夫妻感情出现隔阂。");
            put(5.6, "心地善良，说话做事，心直口快，而且藏不住秘密，心里想什么都表现在脸上。在生活中不拘小节、有点糊涂。在为人处事方面容易得罪人。在事业上没有主见，容易被他人牵着鼻子走。年少时盲目奔波又吃力不讨好。等到中年时期心智成熟之后，事业能慢慢好起来。异性缘不错，会拥有一段不错的婚姻。");
            put(5.7, "才貌双全、蕙质兰心，手巧心细，非常讨人喜欢。早年时期，无论是生活还是事业上，不仅桃花很旺盛，就连带着事业也非常顺利。能够在年轻的时候，找到一个门当户对的依靠。夫妻二人齐心协力，共同拼搏，在不久的将来，不仅会成为人人称赞的模范夫妻，自己子女也能在你们良好的教育之下，成龙成风。");
            put(5.8, "口快心直，品德高尚，能力出众，一生衣食无忧，容易好心没有好报。年少时运气不好，命运多舛，子女、兄弟姐妹帮助少，中年虽然有些辛苦、奔忙，但可成事，外出发展最好，身体不好的丈夫也会逐渐恢复健康。晚年顺心如意。");
            put(5.9, "年轻时八字自强，除了吃很多苦，还缺乏帮助，好朋友帮不了你。自己的健康状况有时会影响婚姻，不能顺利进行。");
            put(6.0, "不仅心地善良，聪明伶俐，而且年少的时候勤奋刻苦，属于校园时期的数一数二的品学兼优的好学生。等到工作之后，事业顺利，财运旺盛，而且还可能在事业上遇到命中贵人。婚姻方面也可以说是十分顺利美满，选择的伴侣不是能力比你强的，也是社会地位比较高的人。");
            put(6.1, "性格坚韧不拔且心急，不会欺负弱小，也不会胆怯怕事。在年轻时经历了许多困难和考验，锻炼了自己。并不能依靠亲人和子女，运势不佳，事业发展困难，常常不如意。然而不应该因此而气馁或者满足于现状，更不能采取投机取巧的方式，而是要脚踏实地地努力。在30岁左右，需要特别注意自身的安全。而到了中年时运势会逐渐好转，不仅能够获得正财，还会有偏财运，在事业上能够取得成功并名扬一时。而到了60岁以后，运势会更加顺利。");
            put(6.2, "心地善良、聪明伶俐，为人机警，无论是生活上还是事业中，都有不错的运气。一生运气不错，可以说是事事称心、事事如意，就连失踪多年的亲人都能够再次相遇。事业方面不仅有好的机遇，而且是节节高升，身体状况也可以说是非常好的，尤其是晚年的时候，儿女很是孝顺，对命主的照顾很是周到，晚年清闲享福。");
            put(6.3, "一生运势跌宕起伏，而且要小心脸色不要破相，否则一生都很难转运；建议在年轻的时候，一定要树立好的金钱观，这样下半生自然会衣食无忧，财源滚滚来。");
            put(6.4, "聪明机灵，随机应变能力很强，而且性格比较刚烈，有点像男孩子的性格。事业运气稍微差了一点，因此在早年时期可能一直处于独自奔波的劳碌状况。建议考虑先成家，多一个人一起打拼事业，说不定对自己更好一点呢。");
            put(6.5, "一生运势真是了不得，财运、事业都是非常不错的，年轻的时候就已经往非常不错的趋势发展，晚年的时候也能够名扬四海，受人尊敬赞扬。要注意害人之心不可有，防人之心也不可无。");
            put(6.6, "为人正直、坚强，心地善良，没有恶意、品行端正，勤劳节俭，擅长管理家务，家庭生活稳定和谐、幸福，能够遇难成祥。适合从事经商，因为财富会日渐增长。子女可能会较晚出生，但和丈夫之间没有相克的问题。");
            put(6.7, "为人和善，心胸宽广，聪明伶俐，手足姊妹子女均可称心。中年人运势不好，操劳劳累，行事不顺，要注意身心健康、易生病、婚姻欠佳，注意言辞是非，不乱问。后半生，生活安定，丰衣足食，家庭焕然一新。");
            put(6.8, "待人接物方面具有出色的才华，聪明伶俐，口齿伶俐，能言善辩，举止文静，待人彬彬有礼，并因此受到他人的尊敬。早年命运并不顺利，需要从零开始努力打拼，赚取外地的财富。身体方面也不是十分康健，容易生病，因此需要特别注意身体保养。姻缘方面来得比较晚。不适合与他人合伙做事。中年开始的时候也会遇到一些不顺利，需要注意灾祸的发生。然而，从45、6岁开始，运气将逐渐好转，时来运转，家庭将会和睦、祥瑞，夫妻可以百年好合。");
            put(6.9, "出生家庭优越，命运十分不错，不是普通人，有稳定的收入来源，财运不错。有正财和偏财的运势，有合伙经营的机会，而且做生意也是十分不错的。一些小病、小灾以及口舌是非等，也能够轻易地解决。只要能够安于律己，不骄傲、放纵，多磨炼自己的心智，坚定意志，多行善事，修正自身的不足，一生都会过着富贵、平稳的生活。");
            put(7.0, "清新脱俗，温柔优雅，和老公如胶似漆，很恩爱，一生运气好。福气、财富、长寿是这种生活的真实写照。同时要保持低调谦逊，不要骄傲，多做好事，福报会持续。");
            put(7.1, "具备坚定的意志和执着的品质。在事业上将会取得较大的成功。有着出色的领导能力和决策能力，能够在职场中脱颖而出。不需要过度努力，但也不能过于懒散，要保持积极进取的态度，不断学习和提升自己的能力。建议在事业上保持自信和冷静，善于与人合作，同时也要注意避免过度控制和强势的表现，以免引起他人的反感。");
        }
    };

    /**
     * 五行分析（根据年柱纳音五行计算）
     */
    public static final Map<String, String> WU_XING_FEN_XI = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("木", "木主仁，温柔随和，待人友善，富有同情心，有很强的正义感，能够结识到比较不错的朋友。在事业上认真踏实，但事业心并不强，为人处事乐观豁达，但是有时候会太过固执，而在无形中得罪人。");
            put("火", "火主礼，热情乐观，开朗大度，永远都精神饱满，遇事总会冲在最前方，待人谦虚淳朴，讲礼貌，也因此而受到大家的尊敬。但是也会因为太过于冲动，而失去理智，做事不计较后果，得罪人。");
            put("土", "土主信，为人厚道，信守承诺，处事大度，懂得知恩图报，对待父母非常孝顺。在生活中哪怕自己吃亏，也不会去占别人的便宜，常常受到大家的信赖。不过有时也固执己见，八匹马也拉不回来，缺乏变通。");
            put("金", "金主义，爱憎分明，嫉恶如仇，做事果断认真，具有远见，且有较强的组织能力。很重视情义，朋友有事，定会竭尽所能的去帮助。不过遇事会过于急躁，喜欢以自我为中心。");
            put("水", "水主智，足智多谋，聪明好学，深谋远虑。无论做什么事情都是非常有计划性的，绝不会盲目的去做。在生活中见多识广，人缘好，朋友多，对待感情很专一。不过由于做事太细致，会出现犹豫不决的情况，不敢去冒风险。");
        }
    };

//----------------------------------------------------------------------------------------------------------------------------------------------------

    /**
     * 十神
     */
    public static final Map<String, String> SHI_SHEN_MAP = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            十神的生克关系：

                1、生我者为印缓（五行阴阳属性相同则为：枭神(偏印)，五行阴阳属性不同则为：正印）
                2、我生者为子孙（五行阴阳属性相同则为：食神，五行阴阳属性不同则为：伤官）
                3、克我者为官鬼（五行阴阳属性相同则为：七杀(偏宫)，五行阴阳属性不同则为：正官）
                4、我克者为妻财（五行阴阳属性相同则为：才财(偏财)，五行阴阳属性不同则为：正财）
                5、同我者为兄弟（五行阴阳属性相同则为：比肩，五行阴阳属性不同则为：劫财）
         */ {                    // 我+者（即：日干+其他干支）
            put("甲甲", "比肩"); // 甲+甲（阳木+阳木）：比肩
            put("甲乙", "劫财"); // 甲+乙（阳木+阴木）：劫财
            put("甲丙", "食神"); // 甲+丙（阳木+阳火）：食神
            put("甲丁", "伤官"); // 甲+丁（阳木+阴火）：伤官
            put("甲戊", "才财"); // 甲+戊（阳木+阳土）：才财(偏财)
            put("甲己", "正财"); // 甲+己（阳木+阴土）：正财
            put("甲庚", "七杀"); // 甲+庚（阳木+阳金）：七杀(偏宫)
            put("甲辛", "正官"); // 甲+辛（阳木+阴金）：正官
            put("甲壬", "枭神"); // 甲+壬（阳木+阳水）：枭神(偏印)
            put("甲癸", "正印"); // 甲+癸（阳木+阴水）：正印
            put("甲子", "枭神"); // 甲+子（阳木+阳水）：枭神(偏印)
            put("甲丑", "正财"); // 甲+丑（阳木+阴土）：正财
            put("甲寅", "比肩"); // 甲+寅（阳木+阳木）：比肩
            put("甲卯", "劫财"); // 甲+卯（阳木+阴木）：劫财
            put("甲辰", "才财"); // 甲+辰（阳木+阳土）：才财(偏财)
            put("甲巳", "伤官"); // 甲+巳（阳木+阴火）：伤官
            put("甲午", "食神"); // 甲+午（阳木+阳火）：食神
            put("甲未", "正财"); // 甲+未（阳木+阴土）：正财
            put("甲申", "七杀"); // 甲+申（阳木+阳金）：七杀(偏宫)
            put("甲酉", "正官"); // 甲+酉（阳木+阴金）：正官
            put("甲戌", "才财"); // 甲+戌（阳木+阳土）：才财(偏财)
            put("甲亥", "正印"); // 甲+亥（阳木+阴水）：正印
            put("乙甲", "劫财"); // 乙+甲（阴木+阳木）：劫财
            put("乙乙", "比肩"); // 乙+乙（阴木+阴木）：比肩
            put("乙丙", "伤官"); // 乙+丙（阴木+阳火）：伤官
            put("乙丁", "食神"); // 乙+丁（阴木+阴火）：食神
            put("乙戊", "正财"); // 乙+戊（阴木+阳土）：正财
            put("乙己", "才财"); // 乙+己（阴木+阴土）：才财(偏财)
            put("乙庚", "正官"); // 乙+庚（阴木+阳金）：正官
            put("乙辛", "七杀"); // 乙+辛（阴木+阴金）：七杀(偏宫)
            put("乙壬", "正印"); // 乙+壬（阴木+阳水）：正印
            put("乙癸", "枭神"); // 乙+癸（阴木+阴水）：枭神(偏印)
            put("乙子", "正印"); // 乙+子（阴木+阳水）：正印
            put("乙丑", "才财"); // 乙+丑（阴木+阴土）：才财(偏财)
            put("乙寅", "劫财"); // 乙+寅（阴木+阳木）：劫财
            put("乙卯", "比肩"); // 乙+卯（阴木+阴木）：比肩
            put("乙辰", "正财"); // 乙+辰（阴木+阳土）：正财
            put("乙巳", "食神"); // 乙+巳（阴木+阴火）：食神
            put("乙午", "伤官"); // 乙+午（阴木+阳火）：伤官
            put("乙未", "才财"); // 乙+未（阴木+阴土）：才财(偏财)
            put("乙申", "正官"); // 乙+申（阴木+阳金）：正官
            put("乙酉", "七杀"); // 乙+酉（阴木+阴金）：七杀(偏宫)
            put("乙戌", "正财"); // 乙+戌（阴木+阳土）：正财
            put("乙亥", "枭神"); // 乙+亥（阴木+阴水）：枭神(偏印)
            put("丙甲", "枭神"); // 丙+甲（阳火+阳木）：枭神(偏印)
            put("丙乙", "正印"); // 丙+乙（阳火+阴木）：正印
            put("丙丙", "比肩"); // 丙+丙（阳火+阳火）：比肩
            put("丙丁", "劫财"); // 丙+丁（阳火+阴火）：劫财
            put("丙戊", "食神"); // 丙+戊（阳火+阳土）：食神
            put("丙己", "伤官"); // 丙+己（阳火+阴土）：伤官
            put("丙庚", "才财"); // 丙+庚（阳火+阳金）：才财(偏财)
            put("丙辛", "正财"); // 丙+辛（阳火+阴金）：正财
            put("丙壬", "七杀"); // 丙+壬（阳火+阳水）：七杀(偏宫)
            put("丙癸", "正官"); // 丙+癸（阳火+阴水）：正官
            put("丙子", "七杀"); // 丙+子（阳火+阳水）：七杀(偏宫)
            put("丙丑", "伤官"); // 丙+丑（阳火+阴土）：伤官
            put("丙寅", "枭神"); // 丙+寅（阳火+阳木）：枭神(偏印)
            put("丙卯", "正印"); // 丙+卯（阳火+阴木）：正印
            put("丙辰", "食神"); // 丙+辰（阳火+阳土）：食神
            put("丙巳", "劫财"); // 丙+巳（阳火+阴火）：劫财
            put("丙午", "比肩"); // 丙+午（阳火+阳火）：比肩
            put("丙未", "伤官"); // 丙+未（阳火+阴土）：伤官
            put("丙申", "才财"); // 丙+申（阳火+阳金）：才财(偏财)
            put("丙酉", "正财"); // 丙+酉（阳火+阴金）：正财
            put("丙戌", "食神"); // 丙+戌（阳火+阳土）：食神
            put("丙亥", "正官"); // 丙+亥（阳火+阴水）：正官
            put("丁甲", "正印"); // 丁+甲（阴火+阳木）：正印
            put("丁乙", "枭神"); // 丁+乙（阴火+阴木）：枭神(偏印)
            put("丁丙", "劫财"); // 丁+丙（阴火+阳火）：劫财
            put("丁丁", "比肩"); // 丁+丁（阴火+阴火）：比肩
            put("丁戊", "伤官"); // 丁+戊（阴火+阳土）：伤官
            put("丁己", "食神"); // 丁+己（阴火+阴土）：食神
            put("丁庚", "正财"); // 丁+庚（阴火+阳金）：正财
            put("丁辛", "才财"); // 丁+辛（阴火+阴金）：才财(偏财)
            put("丁壬", "正官"); // 丁+壬（阴火+阳水）：正官
            put("丁癸", "七杀"); // 丁+癸（阴火+阴水）：七杀(偏宫)
            put("丁子", "正官"); // 丁+子（阴火+阳水）：正官
            put("丁丑", "食神"); // 丁+丑（阴火+阴土）：食神
            put("丁寅", "正印"); // 丁+寅（阴火+阳木）：正印
            put("丁卯", "枭神"); // 丁+卯（阴火+阴木）：枭神(偏印)
            put("丁辰", "伤官"); // 丁+辰（阴火+阳土）：伤官
            put("丁巳", "比肩"); // 丁+巳（阴火+阴火）：比肩
            put("丁午", "劫财"); // 丁+午（阴火+阳火）：劫财
            put("丁未", "食神"); // 丁+未（阴火+阴土）：食神
            put("丁申", "正财"); // 丁+申（阴火+阳金）：正财
            put("丁酉", "才财"); // 丁+酉（阴火+阴金）：才财(偏财)
            put("丁戌", "伤官"); // 丁+戌（阴火+阳土）：伤官
            put("丁亥", "七杀"); // 丁+亥（阴火+阴水）：七杀(偏宫)
            put("戊甲", "七杀"); // 戊+甲（阳土+阳木）：七杀(偏宫)
            put("戊乙", "正官"); // 戊+乙（阳土+阴木）：正官
            put("戊丙", "枭神"); // 戊+丙（阳土+阳火）：枭神(偏印)
            put("戊丁", "正印"); // 戊+丁（阳土+阴火）：正印
            put("戊戊", "比肩"); // 戊+戊（阳土+阳土）：比肩
            put("戊己", "劫财"); // 戊+己（阳土+阴土）：劫财
            put("戊庚", "食神"); // 戊+庚（阳土+阳金）：食神
            put("戊辛", "伤官"); // 戊+辛（阳土+阴金）：伤官
            put("戊壬", "才财"); // 戊+壬（阳土+阳水）：才财(偏财)
            put("戊癸", "正财"); // 戊+癸（阳土+阴水）：正财
            put("戊子", "才财"); // 戊+子（阳土+阳水）：才财(偏财)
            put("戊丑", "劫财"); // 戊+丑（阳土+阴土）：劫财
            put("戊寅", "七杀"); // 戊+寅（阳土+阳木）：七杀(偏宫)
            put("戊卯", "正官"); // 戊+卯（阳土+阴木）：正官
            put("戊辰", "比肩"); // 戊+辰（阳土+阳土）：比肩
            put("戊巳", "正印"); // 戊+巳（阳土+阴火）：正印
            put("戊午", "枭神"); // 戊+午（阳土+阳火）：枭神(偏印)
            put("戊未", "劫财"); // 戊+未（阳土+阴土）：劫财
            put("戊申", "食神"); // 戊+申（阳土+阳金）：食神
            put("戊酉", "伤官"); // 戊+酉（阳土+阴金）：伤官
            put("戊戌", "比肩"); // 戊+戌（阳土+阳土）：比肩
            put("戊亥", "正财"); // 戊+亥（阳土+阴水）：正财
            put("己甲", "正官"); // 己+甲（阴土+阳木）：正官
            put("己乙", "七杀"); // 己+乙（阴土+阴木）：七杀(偏宫)
            put("己丙", "正印"); // 己+丙（阴土+阳火）：正印
            put("己丁", "枭神"); // 己+丁（阴土+阴火）：枭神(偏印)
            put("己戊", "劫财"); // 己+戊（阴土+阳土）：劫财
            put("己己", "比肩"); // 己+己（阴土+阴土）：比肩
            put("己庚", "伤官"); // 己+庚（阴土+阳金）：伤官
            put("己辛", "食神"); // 己+辛（阴土+阴金）：食神
            put("己壬", "正财"); // 己+壬（阴土+阳水）：正财
            put("己癸", "才财"); // 己+癸（阴土+阴水）：才财(偏财)
            put("己子", "正财"); // 己+子（阴土+阳水）：正财
            put("己丑", "比肩"); // 己+丑（阴土+阴土）：比肩
            put("己寅", "正官"); // 己+寅（阴土+阳木）：正官
            put("己卯", "七杀"); // 己+卯（阴土+阴木）：七杀(偏宫)
            put("己辰", "劫财"); // 己+辰（阴土+阳土）：劫财
            put("己巳", "枭神"); // 己+巳（阴土+阴火）：枭神(偏印)
            put("己午", "正印"); // 己+午（阴土+阳火）：正印
            put("己未", "比肩"); // 己+未（阴土+阴土）：比肩
            put("己申", "伤官"); // 己+申（阴土+阳金）：伤官
            put("己酉", "食神"); // 己+酉（阴土+阴金）：食神
            put("己戌", "劫财"); // 己+戌（阴土+阳土）：劫财
            put("己亥", "才财"); // 己+亥（阴土+阴水）：才财(偏财)
            put("庚甲", "才财"); // 庚+甲（阳金+阳木）：才财(偏财)
            put("庚乙", "正财"); // 庚+乙（阳金+阴木）：正财
            put("庚丙", "七杀"); // 庚+丙（阳金+阳火）：七杀(偏宫)
            put("庚丁", "正官"); // 庚+丁（阳金+阴火）：正官
            put("庚戊", "枭神"); // 庚+戊（阳金+阳土）：枭神(偏印)
            put("庚己", "正印"); // 庚+己（阳金+阴土）：正印
            put("庚庚", "比肩"); // 庚+庚（阳金+阳金）：比肩
            put("庚辛", "劫财"); // 庚+辛（阳金+阴金）：劫财
            put("庚壬", "食神"); // 庚+壬（阳金+阳水）：食神
            put("庚癸", "伤官"); // 庚+癸（阳金+阴水）：伤官
            put("庚子", "食神"); // 庚+子（阳金+阳水）：食神
            put("庚丑", "正印"); // 庚+丑（阳金+阴土）：正印
            put("庚寅", "才财"); // 庚+寅（阳金+阳木）：才财(偏财)
            put("庚卯", "正财"); // 庚+卯（阳金+阴木）：正财
            put("庚辰", "枭神"); // 庚+辰（阳金+阳土）：枭神(偏印)
            put("庚巳", "正官"); // 庚+巳（阳金+阴火）：正官
            put("庚午", "七杀"); // 庚+午（阳金+阳火）：七杀(偏宫)
            put("庚未", "正印"); // 庚+未（阳金+阴土）：正印
            put("庚申", "比肩"); // 庚+申（阳金+阳金）：比肩
            put("庚酉", "劫财"); // 庚+酉（阳金+阴金）：劫财
            put("庚戌", "枭神"); // 庚+戌（阳金+阳土）：枭神(偏印)
            put("庚亥", "伤官"); // 庚+亥（阳金+阴水）：伤官
            put("辛甲", "正财"); // 辛+甲（阴金+阳木）：正财
            put("辛乙", "才财"); // 辛+乙（阴金+阴木）：才财(偏财)
            put("辛丙", "正官"); // 辛+丙（阴金+阳火）：正官
            put("辛丁", "七杀"); // 辛+丁（阴金+阴火）：七杀(偏宫)
            put("辛戊", "正印"); // 辛+戊（阴金+阳土）：正印
            put("辛己", "枭神"); // 辛+己（阴金+阴土）：枭神(偏印)
            put("辛庚", "劫财"); // 辛+庚（阴金+阳金）：劫财
            put("辛辛", "比肩"); // 辛+辛（阴金+阴金）：比肩
            put("辛壬", "伤官"); // 辛+壬（阴金+阳水）：伤官
            put("辛癸", "食神"); // 辛+癸（阴金+阴水）：食神
            put("辛子", "伤官"); // 辛+子（阴金+阳水）：伤官
            put("辛丑", "枭神"); // 辛+丑（阴金+阴土）：枭神(偏印)
            put("辛寅", "正财"); // 辛+寅（阴金+阳木）：正财
            put("辛卯", "才财"); // 辛+卯（阴金+阴木）：才财(偏财)
            put("辛辰", "正印"); // 辛+辰（阴金+阳土）：正印
            put("辛巳", "七杀"); // 辛+巳（阴金+阴火）：七杀(偏宫)
            put("辛午", "正官"); // 辛+午（阴金+阳火）：正官
            put("辛未", "枭神"); // 辛+未（阴金+阴土）：枭神(偏印)
            put("辛申", "劫财"); // 辛+申（阴金+阳金）：劫财
            put("辛酉", "比肩"); // 辛+酉（阴金+阴金）：比肩
            put("辛戌", "正印"); // 辛+戌（阴金+阳土）：正印
            put("辛亥", "食神"); // 辛+亥（阴金+阴水）：食神
            put("壬甲", "食神"); // 壬+甲（阳水+阳木）：食神
            put("壬乙", "伤官"); // 壬+乙（阳水+阴木）：伤官
            put("壬丙", "才财"); // 壬+丙（阳水+阳火）：才财(偏财)
            put("壬丁", "正财"); // 壬+丁（阳水+阴火）：正财
            put("壬戊", "七杀"); // 壬+戊（阳水+阳土）：七杀(偏宫)
            put("壬己", "正官"); // 壬+己（阳水+阴土）：正官
            put("壬庚", "枭神"); // 壬+庚（阳水+阳金）：枭神(偏印)
            put("壬辛", "正印"); // 壬+辛（阳水+阴金）：正印
            put("壬壬", "比肩"); // 壬+壬（阳水+阳水）：比肩
            put("壬癸", "劫财"); // 壬+癸（阳水+阴水）：劫财
            put("壬子", "比肩"); // 壬+子（阳水+阳水）：比肩
            put("壬丑", "正官"); // 壬+丑（阳水+阴土）：正官
            put("壬寅", "食神"); // 壬+寅（阳水+阳木）：食神
            put("壬卯", "伤官"); // 壬+卯（阳水+阴木）：伤官
            put("壬辰", "七杀"); // 壬+辰（阳水+阳土）：七杀(偏宫)
            put("壬巳", "正财"); // 壬+巳（阳水+阴火）：正财
            put("壬午", "才财"); // 壬+午（阳水+阳火）：才财(偏财)
            put("壬未", "正官"); // 壬+未（阳水+阴土）：正官
            put("壬申", "枭神"); // 壬+申（阳水+阳金）：枭神(偏印)
            put("壬酉", "正印"); // 壬+酉（阳水+阴金）：正印
            put("壬戌", "七杀"); // 壬+戌（阳水+阳土）：七杀(偏宫)
            put("壬亥", "劫财"); // 壬+亥（阳水+阴水）：劫财
            put("癸甲", "伤官"); // 癸+甲（阴水+阳木）：伤官
            put("癸乙", "食神"); // 癸+乙（阴水+阴木）：食神
            put("癸丙", "正财"); // 癸+丙（阴水+阳火）：正财
            put("癸丁", "才财"); // 癸+丁（阴水+阴火）：才财(偏财)
            put("癸戊", "正官"); // 癸+戊（阴水+阳土）：正官
            put("癸己", "七杀"); // 癸+己（阴水+阴土）：七杀(偏宫)
            put("癸庚", "正印"); // 癸+庚（阴水+阳金）：正印
            put("癸辛", "枭神"); // 癸+辛（阴水+阴金）：枭神(偏印)
            put("癸壬", "劫财"); // 癸+壬（阴水+阳水）：劫财
            put("癸癸", "比肩"); // 癸+癸（阴水+阴水）：比肩
            put("癸子", "劫财"); // 癸+子（阴水+阳水）：劫财
            put("癸丑", "七杀"); // 癸+丑（阴水+阴土）：七杀(偏宫)
            put("癸寅", "伤官"); // 癸+寅（阴水+阳木）：伤官
            put("癸卯", "食神"); // 癸+卯（阴水+阴木）：食神
            put("癸辰", "正官"); // 癸+辰（阴水+阳土）：正官
            put("癸巳", "才财"); // 癸+巳（阴水+阴火）：才财(偏财)
            put("癸午", "正财"); // 癸+午（阴水+阳火）：正财
            put("癸未", "七杀"); // 癸+未（阴水+阴土）：七杀(偏宫)
            put("癸申", "正印"); // 癸+申（阴水+阳金）：正印
            put("癸酉", "枭神"); // 癸+酉（阴水+阴金）：枭神(偏印)
            put("癸戌", "正官"); // 癸+戌（阴水+阳土）：正官
            put("癸亥", "比肩"); // 癸+亥（阴水+阴水）：比肩
        }
    };

    /**
     * 男女日主正财（日干+流年天干或地支）
     */
    public static final Map<String, List<String>> RI_ZHU_ZHENG_CAI = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            我克者为财（男女通用）

                甲的正财为：己、未、丑
                乙的正财为：戊、辰、戌
                丙的正财为：辛、酉
                丁的正财为：庚、申
                戊的正财为：癸、亥
                己的正财为：壬、子
                庚的正财为：乙、卯
                辛的正财为：甲、寅
                壬的正财为：丁、巳
                癸的正财为：丙、午
        */ {
            put("甲", Arrays.asList("己", "丑", "未"));
            put("乙", Arrays.asList("戊", "辰", "戌"));
            put("丙", Arrays.asList("辛", "酉"));
            put("丁", Arrays.asList("庚", "申"));
            put("戊", Arrays.asList("癸", "亥"));
            put("己", Arrays.asList("壬", "子"));
            put("庚", Arrays.asList("乙", "卯"));
            put("辛", Arrays.asList("甲", "寅"));
            put("壬", Arrays.asList("丁", "巳"));
            put("癸", Arrays.asList("丙", "午"));
        }
    };

    /**
     * 男女日主偏财（日干+流年天干或地支）
     */
    public static final Map<String, List<String>> RI_ZHU_PIAN_CAI = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            我克者为财（男女通用）

                甲的偏财为：戊、辰、戌
                乙的偏财为：己、未、丑
                丙的偏财为：庚、申
                丁的偏财为：辛、酉
                戊的偏财为：壬、子
                己的偏财为：癸、亥
                庚的偏财为：甲、寅
                辛的偏财为：乙、卯
                壬的偏财为：丙、午
                癸的偏财为：丁、巳
        */ {
            put("甲", Arrays.asList("戊", "辰", "戌"));
            put("乙", Arrays.asList("己", "丑", "未"));
            put("丙", Arrays.asList("庚", "申"));
            put("丁", Arrays.asList("辛", "酉"));
            put("戊", Arrays.asList("壬", "子"));
            put("己", Arrays.asList("癸", "亥"));
            put("庚", Arrays.asList("甲", "寅"));
            put("辛", Arrays.asList("乙", "卯"));
            put("壬", Arrays.asList("丙", "午"));
            put("癸", Arrays.asList("丁", "巳"));
        }
    };

    /**
     * 男日主正财（日干+流年天干或地支）
     */
    public static final Map<String, List<String>> NAN_RI_ZHU_ZHENG_TAO_HUA = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            我克者为桃花

                甲的正桃花为：己、未、丑
                乙的正桃花为：戊、辰、戌
                丙的正桃花为：辛、酉
                丁的正桃花为：庚、申
                戊的正桃花为：癸、亥
                己的正桃花为：壬、子
                庚的正桃花为：乙、卯
                辛的正桃花为：甲、寅
                壬的正桃花为：丁、巳
                癸的正桃花为：丙、午
        */ {
            put("甲", Arrays.asList("己", "丑", "未"));
            put("乙", Arrays.asList("戊", "辰", "戌"));
            put("丙", Arrays.asList("辛", "酉"));
            put("丁", Arrays.asList("庚", "申"));
            put("戊", Arrays.asList("癸", "亥"));
            put("己", Arrays.asList("壬", "子"));
            put("庚", Arrays.asList("乙", "卯"));
            put("辛", Arrays.asList("甲", "寅"));
            put("壬", Arrays.asList("丁", "巳"));
            put("癸", Arrays.asList("丙", "午"));
        }
    };

    /**
     * 男日主偏财（日干+流年天干或地支）
     */
    public static final Map<String, List<String>> NAN_RI_ZHU_PIAN_TAO_HUA = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            我克者为桃花

                甲的偏桃花为：戊、辰、戌
                乙的偏桃花为：己、未、丑
                丙的偏桃花为：庚、申
                丁的偏桃花为：辛、酉
                戊的偏桃花为：壬、子
                己的偏桃花为：癸、亥
                庚的偏桃花为：甲、寅
                辛的偏桃花为：乙、卯
                壬的偏桃花为：丙、午
                癸的偏桃花为：丁、巳
        */ {
            put("甲", Arrays.asList("戊", "辰", "戌"));
            put("乙", Arrays.asList("己", "丑", "未"));
            put("丙", Arrays.asList("庚", "申"));
            put("丁", Arrays.asList("辛", "酉"));
            put("戊", Arrays.asList("壬", "子"));
            put("己", Arrays.asList("癸", "亥"));
            put("庚", Arrays.asList("甲", "寅"));
            put("辛", Arrays.asList("乙", "卯"));
            put("壬", Arrays.asList("丙", "午"));
            put("癸", Arrays.asList("丁", "巳"));
        }
    };

    /**
     * 女日主正财（日干+流年天干或地支）
     */
    public static final Map<String, List<String>> NV_RI_ZHU_ZHENG_TAO_HUA = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            克我者为桃花

                甲的正桃花为：辛、酉
                乙的正桃花为：庚、申
                丙的正桃花为：癸、亥
                丁的正桃花为：壬、子
                戊的正桃花为：乙、卯
                己的正桃花为：甲、寅
                庚的正桃花为：丁、午
                辛的正桃花为：丙、巳
                壬的正桃花为：己、丑、未
                癸的正桃花为：戊、辰、戌
        */ {
            put("甲", Arrays.asList("辛", "酉"));
            put("乙", Arrays.asList("庚", "申"));
            put("丙", Arrays.asList("癸", "亥"));
            put("丁", Arrays.asList("壬", "子"));
            put("戊", Arrays.asList("乙", "卯"));
            put("己", Arrays.asList("甲", "寅"));
            put("庚", Arrays.asList("丁", "午"));
            put("辛", Arrays.asList("丙", "巳"));
            put("壬", Arrays.asList("己", "丑", "未"));
            put("癸", Arrays.asList("戊", "辰", "戌"));
        }
    };

    /**
     * 女日主偏财（日干+流年天干或地支）
     */
    public static final Map<String, List<String>> NV_RI_ZHU_PIAN_TAO_HUA = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            克我者为桃花

                甲的偏桃花为：庚、申
                乙的偏桃花为：辛、酉
                丙的偏桃花为：壬、子
                丁的偏桃花为：癸、亥
                戊的偏桃花为：甲、寅
                己的偏桃花为：乙、卯
                庚的偏桃花为：丙、巳
                辛的偏桃花为：丁、午
                壬的偏桃花为：戊、辰、戌
                癸的偏桃花为：己、丑、未
        */ {
            put("甲", Arrays.asList("庚", "申"));
            put("乙", Arrays.asList("辛", "酉"));
            put("丙", Arrays.asList("壬", "子"));
            put("丁", Arrays.asList("癸", "亥"));
            put("戊", Arrays.asList("甲", "寅"));
            put("己", Arrays.asList("乙", "卯"));
            put("庚", Arrays.asList("丙", "巳"));
            put("辛", Arrays.asList("丁", "午"));
            put("壬", Arrays.asList("戊", "辰", "戌"));
            put("癸", Arrays.asList("己", "丑", "未"));
        }
    };

    /**
     * 身弱运程
     */
    public static final Map<String, String> SHEN_RUO_YUN_CHENG = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
                         身弱
                =======================

                     同我：快速上升
                     生我：慢速上升
                     我生：不升不降
                     我克：慢速下降
                     克我：快速下降
         */ {
            put("甲甲", "快速上升"); // 甲+甲（同我：快速上升）
            put("甲乙", "快速上升"); // 甲+乙（同我：快速上升）
            put("甲丙", "不升不降"); // 甲+丙（我生：不升不降）
            put("甲丁", "不升不降"); // 甲+丁（我生：不升不降）
            put("甲戊", "慢速下降"); // 甲+戊（我克：慢速下降）
            put("甲己", "慢速下降"); // 甲+己（我克：慢速下降）
            put("甲庚", "快速下降"); // 甲+庚（克我：快速下降）
            put("甲辛", "快速下降"); // 甲+辛（克我：快速下降）
            put("甲壬", "慢速上升"); // 甲+壬（生我：慢速上升）
            put("甲癸", "慢速上升"); // 甲+癸（生我：慢速上升）
            put("甲子", "慢速上升"); // 甲+子（生我：慢速上升）
            put("甲丑", "慢速下降"); // 甲+丑（我克：慢速下降）
            put("甲寅", "快速上升"); // 甲+寅（同我：快速上升）
            put("甲卯", "快速上升"); // 甲+卯（同我：快速上升）
            put("甲辰", "慢速下降"); // 甲+辰（我克：慢速下降）
            put("甲巳", "不升不降"); // 甲+巳（我生：不升不降）
            put("甲午", "不升不降"); // 甲+午（我生：不升不降）
            put("甲未", "慢速下降"); // 甲+未（我克：慢速下降）
            put("甲申", "快速下降"); // 甲+申（克我：快速下降）
            put("甲酉", "快速下降"); // 甲+酉（克我：快速下降）
            put("甲戌", "慢速下降"); // 甲+戌（我克：慢速下降）
            put("甲亥", "慢速上升"); // 甲+亥（生我：慢速上升）
            put("乙甲", "快速上升"); // 乙+甲（同我：快速上升）
            put("乙乙", "快速上升"); // 乙+乙（同我：快速上升）
            put("乙丙", "不升不降"); // 乙+丙（我生：不升不降）
            put("乙丁", "不升不降"); // 乙+丁（我生：不升不降）
            put("乙戊", "慢速下降"); // 乙+戊（我克：慢速下降）
            put("乙己", "慢速下降"); // 乙+己（我克：慢速下降）
            put("乙庚", "快速下降"); // 乙+庚（克我：快速下降）
            put("乙辛", "快速下降"); // 乙+辛（克我：快速下降）
            put("乙壬", "慢速上升"); // 乙+壬（生我：慢速上升）
            put("乙癸", "慢速上升"); // 乙+癸（生我：慢速上升）
            put("乙子", "慢速上升"); // 乙+子（生我：慢速上升）
            put("乙丑", "慢速下降"); // 乙+丑（我克：慢速下降）
            put("乙寅", "快速上升"); // 乙+寅（同我：快速上升）
            put("乙卯", "快速上升"); // 乙+卯（同我：快速上升）
            put("乙辰", "慢速下降"); // 乙+辰（我克：慢速下降）
            put("乙巳", "不升不降"); // 乙+巳（我生：不升不降）
            put("乙午", "不升不降"); // 乙+午（我生：不升不降）
            put("乙未", "慢速下降"); // 乙+未（我克：慢速下降）
            put("乙申", "快速下降"); // 乙+申（克我：快速下降）
            put("乙酉", "快速下降"); // 乙+酉（克我：快速下降）
            put("乙戌", "慢速下降"); // 乙+戌（我克：慢速下降）
            put("乙亥", "慢速上升"); // 乙+亥（生我：慢速上升）
            put("丙甲", "慢速上升"); // 丙+甲（生我：慢速上升）
            put("丙乙", "慢速上升"); // 丙+乙（生我：慢速上升）
            put("丙丙", "快速上升"); // 丙+丙（同我：快速上升）
            put("丙丁", "快速上升"); // 丙+丁（同我：快速上升）
            put("丙戊", "不升不降"); // 丙+戊（我生：不升不降）
            put("丙己", "不升不降"); // 丙+己（我生：不升不降）
            put("丙庚", "慢速下降"); // 丙+庚（我克：慢速下降）
            put("丙辛", "慢速下降"); // 丙+辛（我克：慢速下降）
            put("丙壬", "快速下降"); // 丙+壬（克我：快速下降）
            put("丙癸", "快速下降"); // 丙+癸（克我：快速下降）
            put("丙子", "快速下降"); // 丙+子（克我：快速下降）
            put("丙丑", "不升不降"); // 丙+丑（我生：不升不降）
            put("丙寅", "慢速上升"); // 丙+寅（生我：慢速上升）
            put("丙卯", "慢速上升"); // 丙+卯（生我：慢速上升）
            put("丙辰", "不升不降"); // 丙+辰（我生：不升不降）
            put("丙巳", "快速上升"); // 丙+巳（同我：快速上升）
            put("丙午", "快速上升"); // 丙+午（同我：快速上升）
            put("丙未", "不升不降"); // 丙+未（我生：不升不降）
            put("丙申", "慢速下降"); // 丙+申（我克：慢速下降）
            put("丙酉", "慢速下降"); // 丙+酉（我克：慢速下降）
            put("丙戌", "不升不降"); // 丙+戌（我生：不升不降）
            put("丙亥", "快速下降"); // 丙+亥（克我：快速下降）
            put("丁甲", "慢速上升"); // 丁+甲（生我：慢速上升）
            put("丁乙", "慢速上升"); // 丁+乙（生我：慢速上升）
            put("丁丙", "快速上升"); // 丁+丙（同我：快速上升）
            put("丁丁", "快速上升"); // 丁+丁（同我：快速上升）
            put("丁戊", "不升不降"); // 丁+戊（我生：不升不降）
            put("丁己", "不升不降"); // 丁+己（我生：不升不降）
            put("丁庚", "慢速下降"); // 丁+庚（我克：慢速下降）
            put("丁辛", "慢速下降"); // 丁+辛（我克：慢速下降）
            put("丁壬", "快速下降"); // 丁+壬（克我：快速下降）
            put("丁癸", "快速下降"); // 丁+癸（克我：快速下降）
            put("丁子", "快速下降"); // 丁+子（克我：快速下降）
            put("丁丑", "不升不降"); // 丁+丑（我生：不升不降）
            put("丁寅", "慢速上升"); // 丁+寅（生我：慢速上升）
            put("丁卯", "慢速上升"); // 丁+卯（生我：慢速上升）
            put("丁辰", "不升不降"); // 丁+辰（我生：不升不降）
            put("丁巳", "快速上升"); // 丁+巳（同我：快速上升）
            put("丁午", "快速上升"); // 丁+午（同我：快速上升）
            put("丁未", "不升不降"); // 丁+未（我生：不升不降）
            put("丁申", "慢速下降"); // 丁+申（我克：慢速下降）
            put("丁酉", "慢速下降"); // 丁+酉（我克：慢速下降）
            put("丁戌", "不升不降"); // 丁+戌（我生：不升不降）
            put("丁亥", "快速下降"); // 丁+亥（克我：快速下降）
            put("戊甲", "快速下降"); // 戊+甲（克我：快速下降）
            put("戊乙", "快速下降"); // 戊+乙（克我：快速下降）
            put("戊丙", "慢速上升"); // 戊+丙（生我：慢速上升）
            put("戊丁", "慢速上升"); // 戊+丁（生我：慢速上升）
            put("戊戊", "快速上升"); // 戊+戊（同我：快速上升）
            put("戊己", "快速上升"); // 戊+己（同我：快速上升）
            put("戊庚", "不升不降"); // 戊+庚（我生：不升不降）
            put("戊辛", "不升不降"); // 戊+辛（我生：不升不降）
            put("戊壬", "慢速下降"); // 戊+壬（我克：慢速下降）
            put("戊癸", "慢速下降"); // 戊+癸（我克：慢速下降）
            put("戊子", "慢速下降"); // 戊+子（我克：慢速下降）
            put("戊丑", "快速上升"); // 戊+丑（同我：快速上升）
            put("戊寅", "快速下降"); // 戊+寅（克我：快速下降）
            put("戊卯", "快速下降"); // 戊+卯（克我：快速下降）
            put("戊辰", "快速上升"); // 戊+辰（同我：快速上升）
            put("戊巳", "慢速上升"); // 戊+巳（生我：慢速上升）
            put("戊午", "慢速上升"); // 戊+午（生我：慢速上升）
            put("戊未", "快速上升"); // 戊+未（同我：快速上升）
            put("戊申", "不升不降"); // 戊+申（我生：不升不降）
            put("戊酉", "不升不降"); // 戊+酉（我生：不升不降）
            put("戊戌", "快速上升"); // 戊+戌（同我：快速上升）
            put("戊亥", "慢速下降"); // 戊+亥（我克：慢速下降）
            put("己甲", "快速下降"); // 己+甲（克我：快速下降）
            put("己乙", "快速下降"); // 己+乙（克我：快速下降）
            put("己丙", "慢速上升"); // 己+丙（生我：慢速上升）
            put("己丁", "慢速上升"); // 己+丁（生我：慢速上升）
            put("己戊", "快速上升"); // 己+戊（同我：快速上升）
            put("己己", "快速上升"); // 己+己（同我：快速上升）
            put("己庚", "不升不降"); // 己+庚（我生：不升不降）
            put("己辛", "不升不降"); // 己+辛（我生：不升不降）
            put("己壬", "慢速下降"); // 己+壬（我克：慢速下降）
            put("己癸", "慢速下降"); // 己+癸（我克：慢速下降）
            put("己子", "慢速下降"); // 己+子（我克：慢速下降）
            put("己丑", "快速上升"); // 己+丑（同我：快速上升）
            put("己寅", "快速下降"); // 己+寅（克我：快速下降）
            put("己卯", "快速下降"); // 己+卯（克我：快速下降）
            put("己辰", "快速上升"); // 己+辰（同我：快速上升）
            put("己巳", "慢速上升"); // 己+巳（生我：慢速上升）
            put("己午", "慢速上升"); // 己+午（生我：慢速上升）
            put("己未", "快速上升"); // 己+未（同我：快速上升）
            put("己申", "不升不降"); // 己+申（我生：不升不降）
            put("己酉", "不升不降"); // 己+酉（我生：不升不降）
            put("己戌", "快速上升"); // 己+戌（同我：快速上升）
            put("己亥", "慢速下降"); // 己+亥（我克：慢速下降）
            put("庚甲", "慢速下降"); // 庚+甲（我克：慢速下降）
            put("庚乙", "慢速下降"); // 庚+乙（我克：慢速下降）
            put("庚丙", "快速下降"); // 庚+丙（克我：快速下降）
            put("庚丁", "快速下降"); // 庚+丁（克我：快速下降）
            put("庚戊", "慢速上升"); // 庚+戊（生我：慢速上升）
            put("庚己", "慢速上升"); // 庚+己（生我：慢速上升）
            put("庚庚", "快速上升"); // 庚+庚（同我：快速上升）
            put("庚辛", "快速上升"); // 庚+辛（同我：快速上升）
            put("庚壬", "不升不降"); // 庚+壬（我生：不升不降）
            put("庚癸", "不升不降"); // 庚+癸（我生：不升不降）
            put("庚子", "不升不降"); // 庚+子（我生：不升不降）
            put("庚丑", "慢速上升"); // 庚+丑（生我：慢速上升）
            put("庚寅", "慢速下降"); // 庚+寅（我克：慢速下降）
            put("庚卯", "慢速下降"); // 庚+卯（我克：慢速下降）
            put("庚辰", "慢速上升"); // 庚+辰（生我：慢速上升）
            put("庚巳", "快速下降"); // 庚+巳（克我：快速下降）
            put("庚午", "快速下降"); // 庚+午（克我：快速下降）
            put("庚未", "慢速上升"); // 庚+未（生我：慢速上升）
            put("庚申", "快速上升"); // 庚+申（同我：快速上升）
            put("庚酉", "快速上升"); // 庚+酉（同我：快速上升）
            put("庚戌", "慢速上升"); // 庚+戌（生我：慢速上升）
            put("庚亥", "不升不降"); // 庚+亥（我生：不升不降）
            put("辛甲", "慢速下降"); // 辛+甲（我克：慢速下降）
            put("辛乙", "慢速下降"); // 辛+乙（我克：慢速下降）
            put("辛丙", "快速下降"); // 辛+丙（克我：快速下降）
            put("辛丁", "快速下降"); // 辛+丁（克我：快速下降）
            put("辛戊", "慢速上升"); // 辛+戊（生我：慢速上升）
            put("辛己", "慢速上升"); // 辛+己（生我：慢速上升）
            put("辛庚", "快速上升"); // 辛+庚（同我：快速上升）
            put("辛辛", "快速上升"); // 辛+辛（同我：快速上升）
            put("辛壬", "不升不降"); // 辛+壬（我生：不升不降）
            put("辛癸", "不升不降"); // 辛+癸（我生：不升不降）
            put("辛子", "不升不降"); // 辛+子（我生：不升不降）
            put("辛丑", "慢速上升"); // 辛+丑（生我：慢速上升）
            put("辛寅", "慢速下降"); // 辛+寅（我克：慢速下降）
            put("辛卯", "慢速下降"); // 辛+卯（我克：慢速下降）
            put("辛辰", "慢速上升"); // 辛+辰（生我：慢速上升）
            put("辛巳", "快速下降"); // 辛+巳（克我：快速下降）
            put("辛午", "快速下降"); // 辛+午（克我：快速下降）
            put("辛未", "慢速上升"); // 辛+未（生我：慢速上升）
            put("辛申", "快速上升"); // 辛+申（同我：快速上升）
            put("辛酉", "快速上升"); // 辛+酉（同我：快速上升）
            put("辛戌", "慢速上升"); // 辛+戌（生我：慢速上升）
            put("辛亥", "不升不降"); // 辛+亥（我生：不升不降）
            put("壬甲", "不升不降"); // 壬+甲（我生：不升不降）
            put("壬乙", "不升不降"); // 壬+乙（我生：不升不降）
            put("壬丙", "慢速下降"); // 壬+丙（我克：慢速下降）
            put("壬丁", "慢速下降"); // 壬+丁（我克：慢速下降）
            put("壬戊", "快速下降"); // 壬+戊（克我：快速下降）
            put("壬己", "快速下降"); // 壬+己（克我：快速下降）
            put("壬庚", "慢速上升"); // 壬+庚（生我：慢速上升）
            put("壬辛", "慢速上升"); // 壬+辛（生我：慢速上升）
            put("壬壬", "快速上升"); // 壬+壬（同我：快速上升）
            put("壬癸", "快速上升"); // 壬+癸（同我：快速上升）
            put("壬子", "快速上升"); // 壬+子（同我：快速上升）
            put("壬丑", "快速下降"); // 壬+丑（克我：快速下降）
            put("壬寅", "不升不降"); // 壬+寅（我生：不升不降）
            put("壬卯", "不升不降"); // 壬+卯（我生：不升不降）
            put("壬辰", "快速下降"); // 壬+辰（克我：快速下降）
            put("壬巳", "慢速下降"); // 壬+巳（我克：慢速下降）
            put("壬午", "慢速下降"); // 壬+午（我克：慢速下降）
            put("壬未", "快速下降"); // 壬+未（克我：快速下降）
            put("壬申", "慢速上升"); // 壬+申（生我：慢速上升）
            put("壬酉", "慢速上升"); // 壬+酉（生我：慢速上升）
            put("壬戌", "快速下降"); // 壬+戌（克我：快速下降）
            put("壬亥", "快速上升"); // 壬+亥（同我：快速上升）
            put("癸甲", "不升不降"); // 癸+甲（我生：不升不降）
            put("癸乙", "不升不降"); // 癸+乙（我生：不升不降）
            put("癸丙", "慢速下降"); // 癸+丙（我克：慢速下降）
            put("癸丁", "慢速下降"); // 癸+丁（我克：慢速下降）
            put("癸戊", "快速下降"); // 癸+戊（克我：快速下降）
            put("癸己", "快速下降"); // 癸+己（克我：快速下降）
            put("癸庚", "慢速上升"); // 癸+庚（生我：慢速上升）
            put("癸辛", "慢速上升"); // 癸+辛（生我：慢速上升）
            put("癸壬", "快速上升"); // 癸+壬（同我：快速上升）
            put("癸癸", "快速上升"); // 癸+癸（同我：快速上升）
            put("癸子", "快速上升"); // 癸+子（同我：快速上升）
            put("癸丑", "快速下降"); // 癸+丑（克我：快速下降）
            put("癸寅", "不升不降"); // 癸+寅（我生：不升不降）
            put("癸卯", "不升不降"); // 癸+卯（我生：不升不降）
            put("癸辰", "快速下降"); // 癸+辰（克我：快速下降）
            put("癸巳", "慢速下降"); // 癸+巳（我克：慢速下降）
            put("癸午", "慢速下降"); // 癸+午（我克：慢速下降）
            put("癸未", "快速下降"); // 癸+未（克我：快速下降）
            put("癸申", "慢速上升"); // 癸+申（生我：慢速上升）
            put("癸酉", "慢速上升"); // 癸+酉（生我：慢速上升）
            put("癸戌", "快速下降"); // 癸+戌（克我：快速下降）
            put("癸亥", "快速上升"); // 癸+亥（同我：快速上升）
        }
    };

    /**
     * 身强运程
     */
    public static final Map<String, String> SHEN_QIANG_YUN_CHENG = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
                         身强
                =======================

                     我生：快速上升
                     我克：慢速上升
                     克我：不升不降
                     生我：慢速下降
                     同我：快速下降
         */ {
            put("甲甲", "快速下降"); // 甲+甲（同我：快速下降）
            put("甲乙", "快速下降"); // 甲+乙（同我：快速下降）
            put("甲丙", "快速上升"); // 甲+丙（我生：快速上升）
            put("甲丁", "快速上升"); // 甲+丁（我生：快速上升）
            put("甲戊", "慢速上升"); // 甲+戊（我克：慢速上升）
            put("甲己", "慢速上升"); // 甲+己（我克：慢速上升）
            put("甲庚", "不升不降"); // 甲+庚（克我：不升不降）
            put("甲辛", "不升不降"); // 甲+辛（克我：不升不降）
            put("甲壬", "慢速下降"); // 甲+壬（生我：慢速下降）
            put("甲癸", "慢速下降"); // 甲+癸（生我：慢速下降）
            put("甲子", "慢速下降"); // 甲+子（生我：慢速下降）
            put("甲丑", "慢速上升"); // 甲+丑（我克：慢速上升）
            put("甲寅", "快速下降"); // 甲+寅（同我：快速下降）
            put("甲卯", "快速下降"); // 甲+卯（同我：快速下降）
            put("甲辰", "慢速上升"); // 甲+辰（我克：慢速上升）
            put("甲巳", "快速上升"); // 甲+巳（我生：快速上升）
            put("甲午", "快速上升"); // 甲+午（我生：快速上升）
            put("甲未", "慢速上升"); // 甲+未（我克：慢速上升）
            put("甲申", "不升不降"); // 甲+申（克我：不升不降）
            put("甲酉", "不升不降"); // 甲+酉（克我：不升不降）
            put("甲戌", "慢速上升"); // 甲+戌（我克：慢速上升）
            put("甲亥", "慢速下降"); // 甲+亥（生我：慢速下降）
            put("乙甲", "快速下降"); // 乙+甲（同我：快速下降）
            put("乙乙", "快速下降"); // 乙+乙（同我：快速下降）
            put("乙丙", "快速上升"); // 乙+丙（我生：快速上升）
            put("乙丁", "快速上升"); // 乙+丁（我生：快速上升）
            put("乙戊", "慢速上升"); // 乙+戊（我克：慢速上升）
            put("乙己", "慢速上升"); // 乙+己（我克：慢速上升）
            put("乙庚", "不升不降"); // 乙+庚（克我：不升不降）
            put("乙辛", "不升不降"); // 乙+辛（克我：不升不降）
            put("乙壬", "慢速下降"); // 乙+壬（生我：慢速下降）
            put("乙癸", "慢速下降"); // 乙+癸（生我：慢速下降）
            put("乙子", "慢速下降"); // 乙+子（生我：慢速下降）
            put("乙丑", "慢速上升"); // 乙+丑（我克：慢速上升）
            put("乙寅", "快速下降"); // 乙+寅（同我：快速下降）
            put("乙卯", "快速下降"); // 乙+卯（同我：快速下降）
            put("乙辰", "慢速上升"); // 乙+辰（我克：慢速上升）
            put("乙巳", "快速上升"); // 乙+巳（我生：快速上升）
            put("乙午", "快速上升"); // 乙+午（我生：快速上升）
            put("乙未", "慢速上升"); // 乙+未（我克：慢速上升）
            put("乙申", "不升不降"); // 乙+申（克我：不升不降）
            put("乙酉", "不升不降"); // 乙+酉（克我：不升不降）
            put("乙戌", "慢速上升"); // 乙+戌（我克：慢速上升）
            put("乙亥", "慢速下降"); // 乙+亥（生我：慢速下降）
            put("丙甲", "慢速下降"); // 丙+甲（生我：慢速下降）
            put("丙乙", "慢速下降"); // 丙+乙（生我：慢速下降）
            put("丙丙", "快速下降"); // 丙+丙（同我：快速下降）
            put("丙丁", "快速下降"); // 丙+丁（同我：快速下降）
            put("丙戊", "快速上升"); // 丙+戊（我生：快速上升）
            put("丙己", "快速上升"); // 丙+己（我生：快速上升）
            put("丙庚", "慢速上升"); // 丙+庚（我克：慢速上升）
            put("丙辛", "慢速上升"); // 丙+辛（我克：慢速上升）
            put("丙壬", "不升不降"); // 丙+壬（克我：不升不降）
            put("丙癸", "不升不降"); // 丙+癸（克我：不升不降）
            put("丙子", "不升不降"); // 丙+子（克我：不升不降）
            put("丙丑", "快速上升"); // 丙+丑（我生：快速上升）
            put("丙寅", "慢速下降"); // 丙+寅（生我：慢速下降）
            put("丙卯", "慢速下降"); // 丙+卯（生我：慢速下降）
            put("丙辰", "快速上升"); // 丙+辰（我生：快速上升）
            put("丙巳", "快速下降"); // 丙+巳（同我：快速下降）
            put("丙午", "快速下降"); // 丙+午（同我：快速下降）
            put("丙未", "快速上升"); // 丙+未（我生：快速上升）
            put("丙申", "慢速上升"); // 丙+申（我克：慢速上升）
            put("丙酉", "慢速上升"); // 丙+酉（我克：慢速上升）
            put("丙戌", "快速上升"); // 丙+戌（我生：快速上升）
            put("丙亥", "不升不降"); // 丙+亥（克我：不升不降）
            put("丁甲", "慢速下降"); // 丁+甲（生我：慢速下降）
            put("丁乙", "慢速下降"); // 丁+乙（生我：慢速下降）
            put("丁丙", "快速下降"); // 丁+丙（同我：快速下降）
            put("丁丁", "快速下降"); // 丁+丁（同我：快速下降）
            put("丁戊", "快速上升"); // 丁+戊（我生：快速上升）
            put("丁己", "快速上升"); // 丁+己（我生：快速上升）
            put("丁庚", "慢速上升"); // 丁+庚（我克：慢速上升）
            put("丁辛", "慢速上升"); // 丁+辛（我克：慢速上升）
            put("丁壬", "不升不降"); // 丁+壬（克我：不升不降）
            put("丁癸", "不升不降"); // 丁+癸（克我：不升不降）
            put("丁子", "不升不降"); // 丁+子（克我：不升不降）
            put("丁丑", "快速上升"); // 丁+丑（我生：快速上升）
            put("丁寅", "慢速下降"); // 丁+寅（生我：慢速下降）
            put("丁卯", "慢速下降"); // 丁+卯（生我：慢速下降）
            put("丁辰", "快速上升"); // 丁+辰（我生：快速上升）
            put("丁巳", "快速下降"); // 丁+巳（同我：快速下降）
            put("丁午", "快速下降"); // 丁+午（同我：快速下降）
            put("丁未", "快速上升"); // 丁+未（我生：快速上升）
            put("丁申", "慢速上升"); // 丁+申（我克：慢速上升）
            put("丁酉", "慢速上升"); // 丁+酉（我克：慢速上升）
            put("丁戌", "快速上升"); // 丁+戌（我生：快速上升）
            put("丁亥", "不升不降"); // 丁+亥（克我：不升不降）
            put("戊甲", "不升不降"); // 戊+甲（克我：不升不降）
            put("戊乙", "不升不降"); // 戊+乙（克我：不升不降）
            put("戊丙", "慢速下降"); // 戊+丙（生我：慢速下降）
            put("戊丁", "慢速下降"); // 戊+丁（生我：慢速下降）
            put("戊戊", "快速下降"); // 戊+戊（同我：快速下降）
            put("戊己", "快速下降"); // 戊+己（同我：快速下降）
            put("戊庚", "快速上升"); // 戊+庚（我生：快速上升）
            put("戊辛", "快速上升"); // 戊+辛（我生：快速上升）
            put("戊壬", "慢速上升"); // 戊+壬（我克：慢速上升）
            put("戊癸", "慢速上升"); // 戊+癸（我克：慢速上升）
            put("戊子", "慢速上升"); // 戊+子（我克：慢速上升）
            put("戊丑", "快速下降"); // 戊+丑（同我：快速下降）
            put("戊寅", "不升不降"); // 戊+寅（克我：不升不降）
            put("戊卯", "不升不降"); // 戊+卯（克我：不升不降）
            put("戊辰", "快速下降"); // 戊+辰（同我：快速下降）
            put("戊巳", "慢速下降"); // 戊+巳（生我：慢速下降）
            put("戊午", "慢速下降"); // 戊+午（生我：慢速下降）
            put("戊未", "快速下降"); // 戊+未（同我：快速下降）
            put("戊申", "快速上升"); // 戊+申（我生：快速上升）
            put("戊酉", "快速上升"); // 戊+酉（我生：快速上升）
            put("戊戌", "快速下降"); // 戊+戌（同我：快速下降）
            put("戊亥", "慢速上升"); // 戊+亥（我克：慢速上升）
            put("己甲", "不升不降"); // 己+甲（克我：不升不降）
            put("己乙", "不升不降"); // 己+乙（克我：不升不降）
            put("己丙", "慢速下降"); // 己+丙（生我：慢速下降）
            put("己丁", "慢速下降"); // 己+丁（生我：慢速下降）
            put("己戊", "快速下降"); // 己+戊（同我：快速下降）
            put("己己", "快速下降"); // 己+己（同我：快速下降）
            put("己庚", "快速上升"); // 己+庚（我生：快速上升）
            put("己辛", "快速上升"); // 己+辛（我生：快速上升）
            put("己壬", "慢速上升"); // 己+壬（我克：慢速上升）
            put("己癸", "慢速上升"); // 己+癸（我克：慢速上升）
            put("己子", "慢速上升"); // 己+子（我克：慢速上升）
            put("己丑", "快速下降"); // 己+丑（同我：快速下降）
            put("己寅", "不升不降"); // 己+寅（克我：不升不降）
            put("己卯", "不升不降"); // 己+卯（克我：不升不降）
            put("己辰", "快速下降"); // 己+辰（同我：快速下降）
            put("己巳", "慢速下降"); // 己+巳（生我：慢速下降）
            put("己午", "慢速下降"); // 己+午（生我：慢速下降）
            put("己未", "快速下降"); // 己+未（同我：快速下降）
            put("己申", "快速上升"); // 己+申（我生：快速上升）
            put("己酉", "快速上升"); // 己+酉（我生：快速上升）
            put("己戌", "快速下降"); // 己+戌（同我：快速下降）
            put("己亥", "慢速上升"); // 己+亥（我克：慢速上升）
            put("庚甲", "慢速上升"); // 庚+甲（我克：慢速上升）
            put("庚乙", "慢速上升"); // 庚+乙（我克：慢速上升）
            put("庚丙", "不升不降"); // 庚+丙（克我：不升不降）
            put("庚丁", "不升不降"); // 庚+丁（克我：不升不降）
            put("庚戊", "慢速下降"); // 庚+戊（生我：慢速下降）
            put("庚己", "慢速下降"); // 庚+己（生我：慢速下降）
            put("庚庚", "快速下降"); // 庚+庚（同我：快速下降）
            put("庚辛", "快速下降"); // 庚+辛（同我：快速下降）
            put("庚壬", "快速上升"); // 庚+壬（我生：快速上升）
            put("庚癸", "快速上升"); // 庚+癸（我生：快速上升）
            put("庚子", "快速上升"); // 庚+子（我生：快速上升）
            put("庚丑", "慢速下降"); // 庚+丑（生我：慢速下降）
            put("庚寅", "慢速上升"); // 庚+寅（我克：慢速上升）
            put("庚卯", "慢速上升"); // 庚+卯（我克：慢速上升）
            put("庚辰", "慢速下降"); // 庚+辰（生我：慢速下降）
            put("庚巳", "不升不降"); // 庚+巳（克我：不升不降）
            put("庚午", "不升不降"); // 庚+午（克我：不升不降）
            put("庚未", "慢速下降"); // 庚+未（生我：慢速下降）
            put("庚申", "快速下降"); // 庚+申（同我：快速下降）
            put("庚酉", "快速下降"); // 庚+酉（同我：快速下降）
            put("庚戌", "慢速下降"); // 庚+戌（生我：慢速下降）
            put("庚亥", "快速上升"); // 庚+亥（我生：快速上升）
            put("辛甲", "慢速上升"); // 辛+甲（我克：慢速上升）
            put("辛乙", "慢速上升"); // 辛+乙（我克：慢速上升）
            put("辛丙", "不升不降"); // 辛+丙（克我：不升不降）
            put("辛丁", "不升不降"); // 辛+丁（克我：不升不降）
            put("辛戊", "慢速下降"); // 辛+戊（生我：慢速下降）
            put("辛己", "慢速下降"); // 辛+己（生我：慢速下降）
            put("辛庚", "快速下降"); // 辛+庚（同我：快速下降）
            put("辛辛", "快速下降"); // 辛+辛（同我：快速下降）
            put("辛壬", "快速上升"); // 辛+壬（我生：快速上升）
            put("辛癸", "快速上升"); // 辛+癸（我生：快速上升）
            put("辛子", "快速上升"); // 辛+子（我生：快速上升）
            put("辛丑", "慢速下降"); // 辛+丑（生我：慢速下降）
            put("辛寅", "慢速上升"); // 辛+寅（我克：慢速上升）
            put("辛卯", "慢速上升"); // 辛+卯（我克：慢速上升）
            put("辛辰", "慢速下降"); // 辛+辰（生我：慢速下降）
            put("辛巳", "不升不降"); // 辛+巳（克我：不升不降）
            put("辛午", "不升不降"); // 辛+午（克我：不升不降）
            put("辛未", "慢速下降"); // 辛+未（生我：慢速下降）
            put("辛申", "快速下降"); // 辛+申（同我：快速下降）
            put("辛酉", "快速下降"); // 辛+酉（同我：快速下降）
            put("辛戌", "慢速下降"); // 辛+戌（生我：慢速下降）
            put("辛亥", "快速上升"); // 辛+亥（我生：快速上升）
            put("壬甲", "快速上升"); // 壬+甲（我生：快速上升）
            put("壬乙", "快速上升"); // 壬+乙（我生：快速上升）
            put("壬丙", "慢速上升"); // 壬+丙（我克：慢速上升）
            put("壬丁", "慢速上升"); // 壬+丁（我克：慢速上升）
            put("壬戊", "不升不降"); // 壬+戊（克我：不升不降）
            put("壬己", "不升不降"); // 壬+己（克我：不升不降）
            put("壬庚", "慢速下降"); // 壬+庚（生我：慢速下降）
            put("壬辛", "慢速下降"); // 壬+辛（生我：慢速下降）
            put("壬壬", "快速下降"); // 壬+壬（同我：快速下降）
            put("壬癸", "快速下降"); // 壬+癸（同我：快速下降）
            put("壬子", "快速下降"); // 壬+子（同我：快速下降）
            put("壬丑", "不升不降"); // 壬+丑（克我：不升不降）
            put("壬寅", "快速上升"); // 壬+寅（我生：快速上升）
            put("壬卯", "快速上升"); // 壬+卯（我生：快速上升）
            put("壬辰", "不升不降"); // 壬+辰（克我：不升不降）
            put("壬巳", "慢速上升"); // 壬+巳（我克：慢速上升）
            put("壬午", "慢速上升"); // 壬+午（我克：慢速上升）
            put("壬未", "不升不降"); // 壬+未（克我：不升不降）
            put("壬申", "慢速下降"); // 壬+申（生我：慢速下降）
            put("壬酉", "慢速下降"); // 壬+酉（生我：慢速下降）
            put("壬戌", "不升不降"); // 壬+戌（克我：不升不降）
            put("壬亥", "快速下降"); // 壬+亥（同我：快速下降）
            put("癸甲", "快速上升"); // 癸+甲（我生：快速上升）
            put("癸乙", "快速上升"); // 癸+乙（我生：快速上升）
            put("癸丙", "慢速上升"); // 癸+丙（我克：慢速上升）
            put("癸丁", "慢速上升"); // 癸+丁（我克：慢速上升）
            put("癸戊", "不升不降"); // 癸+戊（克我：不升不降）
            put("癸己", "不升不降"); // 癸+己（克我：不升不降）
            put("癸庚", "慢速下降"); // 癸+庚（生我：慢速下降）
            put("癸辛", "慢速下降"); // 癸+辛（生我：慢速下降）
            put("癸壬", "快速下降"); // 癸+壬（同我：快速下降）
            put("癸癸", "快速下降"); // 癸+癸（同我：快速下降）
            put("癸子", "快速下降"); // 癸+子（同我：快速下降）
            put("癸丑", "不升不降"); // 癸+丑（克我：不升不降）
            put("癸寅", "快速上升"); // 癸+寅（我生：快速上升）
            put("癸卯", "快速上升"); // 癸+卯（我生：快速上升）
            put("癸辰", "不升不降"); // 癸+辰（克我：不升不降）
            put("癸巳", "慢速上升"); // 癸+巳（我克：慢速上升）
            put("癸午", "慢速上升"); // 癸+午（我克：慢速上升）
            put("癸未", "不升不降"); // 癸+未（克我：不升不降）
            put("癸申", "慢速下降"); // 癸+申（生我：慢速下降）
            put("癸酉", "慢速下降"); // 癸+酉（生我：慢速下降）
            put("癸戌", "不升不降"); // 癸+戌（克我：不升不降）
            put("癸亥", "快速下降"); // 癸+亥（同我：快速下降）
        }
    };

//----------------------------------------------------------------------------------------------------------------------------------------------------

    /**
     * 太极贵人【1】
     */
    public static final Map<String, List<String>> TAI_JI_GUI_REN = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【太极贵人】算法

                1、年干或日干是'甲'或者'乙'，并且其他地支有'子'或者'午'，则为太极贵人。
                2、年干或日干是'丙'或者'丁'，并且其他地支有'卯'或者'酉'，则为太极贵人。
                3、年干或日干是'戊'或者'己'，并且其他地支有'辰'或者'戌'或者'丑'或者'未'，则为太极贵人。
                4、年干或日干是'庚'或者'辛'，并且其他地支有'寅'或者'亥'，则为太极贵人。
                5、年干或日干是'壬'或者'癸'，并且其他地支有'巳'或者'申'，则为太极贵人。
         */ {
            put("甲", Arrays.asList("子", "午"));
            put("乙", Arrays.asList("子", "午"));
            put("丙", Arrays.asList("卯", "酉"));
            put("丁", Arrays.asList("卯", "酉"));
            put("戊", Arrays.asList("辰", "戌", "丑", "未"));
            put("己", Arrays.asList("辰", "戌", "丑", "未"));
            put("庚", Arrays.asList("寅", "亥"));
            put("辛", Arrays.asList("寅", "亥"));
            put("壬", Arrays.asList("巳", "申"));
            put("癸", Arrays.asList("巳", "申"));
        }
    };

    /**
     * 天乙贵人【1】
     */
    public static final Map<String, List<String>> TIAN_YI_GUI_REN = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【天乙贵人】算法

                1、年干或日干是'甲'，并且其他地支有'丑'或者'未'，则为天乙贵人。
                2、年干或日干是'乙'，并且其他地支有'子'或者'申'，则为天乙贵人。
                3、年干或日干是'丙'，并且其他地支有'酉'或者'亥'，则为天乙贵人。
                4、年干或日干是'丁'，并且其他地支有'酉'或者'亥'，则为天乙贵人。
                5、年干或日干是'戊'，并且其他地支有'丑'或者'未'，则为天乙贵人。
                6、年干或日干是'己'，并且其他地支有'子'或者'申'，则为天乙贵人。
                7、年干或日干是'庚'，并且其他地支有'丑'或者'未'，则为天乙贵人。
                8、年干或日干是'辛'，并且其他地支有'寅'或者'午'，则为天乙贵人。
                9、年干或日干是'壬'，并且其他地支有'卯'或者'巳'，则为天乙贵人。
                10、年干或日干是'癸'，并且其他地支有'卯'或者'巳'，则为天乙贵人。
         */ {
            put("甲", Arrays.asList("丑", "未"));
            put("乙", Arrays.asList("子", "申"));
            put("丙", Arrays.asList("酉", "亥"));
            put("丁", Arrays.asList("酉", "亥"));
            put("戊", Arrays.asList("丑", "未"));
            put("己", Arrays.asList("子", "申"));
            put("庚", Arrays.asList("丑", "未"));
            put("辛", Arrays.asList("寅", "午"));
            put("壬", Arrays.asList("卯", "巳"));
            put("癸", Arrays.asList("卯", "巳"));
        }
    };

    /**
     * 福星贵人【1】
     */
    public static final Map<String, List<String>> FU_XING_GUI_REN = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【福星贵人】算法

                1、年干或日干是'甲'，并且其他地支有'子'或者'寅'，则为福星贵人。
                2、年干或日干是'乙'，并且其他地支有'丑'或者'卯'，则为福星贵人。
                3、年干或日干是'丙'，并且其他地支有'子'或者'寅'，则为福星贵人。
                4、年干或日干是'丁'，并且其他地支有'亥'，则为福星贵人。
                5、年干或日干是'戊'，并且其他地支有'申'，则为福星贵人。
                6、年干或日干是'己'，并且其他地支有'未'，则为福星贵人。
                7、年干或日干是'庚'，并且其他地支有'午'，则为福星贵人。
                8、年干或日干是'辛'，并且其他地支有'巳'，则为福星贵人。
                9、年干或日干是'壬'，并且其他地支有'辰'，则为福星贵人。
                10、年干或日干是'癸'，并且其他地支有'丑'或者'卯'，则为福星贵人。
         */ {
            put("甲", Arrays.asList("子", "寅"));
            put("乙", Arrays.asList("丑", "卯"));
            put("丙", Arrays.asList("子", "寅"));
            put("丁", Collections.singletonList("亥"));
            put("戊", Collections.singletonList("申"));
            put("己", Collections.singletonList("未"));
            put("庚", Collections.singletonList("午"));
            put("辛", Collections.singletonList("巳"));
            put("壬", Collections.singletonList("辰"));
            put("癸", Arrays.asList("丑", "卯"));
        }
    };

    /**
     * 文昌贵人【1】
     */
    public static final Map<String, List<String>> WEN_CHANG_GUI_REN = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【文昌贵人】算法

                1、年干或日干是'甲'，并且其他地支有'巳'，则为文昌贵人。
                2、年干或日干是'乙'，并且其他地支有'午'，则为文昌贵人。
                3、年干或日干是'丙'，并且其他地支有'申'，则为文昌贵人。
                4、年干或日干是'丁'，并且其他地支有'酉'，则为文昌贵人。
                5、年干或日干是'戊'，并且其他地支有'申'，则为文昌贵人。
                6、年干或日干是'己'，并且其他地支有'酉'，则为文昌贵人。
                7、年干或日干是'庚'，并且其他地支有'亥'，则为文昌贵人。
                8、年干或日干是'辛'，并且其他地支有'子'，则为文昌贵人。
                9、年干或日干是'壬'，并且其他地支有'寅'，则为文昌贵人。
                10、年干或日干是'癸'，并且其他地支有'卯'，则为文昌贵人。
         */ {
            put("甲", Collections.singletonList("巳"));
            put("乙", Collections.singletonList("午"));
            put("丙", Collections.singletonList("申"));
            put("丁", Collections.singletonList("酉"));
            put("戊", Collections.singletonList("申"));
            put("己", Collections.singletonList("酉"));
            put("庚", Collections.singletonList("亥"));
            put("辛", Collections.singletonList("子"));
            put("壬", Collections.singletonList("寅"));
            put("癸", Collections.singletonList("卯"));
        }
    };

    /**
     * 天厨贵人【1】
     */
    public static final Map<String, List<String>> TIAN_CHU_GUI_REN = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【天厨贵人】算法

                1、年干或日干是'甲'，并且其他地支有'巳'，则为天厨贵人。
                2、年干或日干是'乙'，并且其他地支有'午'，则为天厨贵人。
                3、年干或日干是'丙'，并且其他地支有'巳'，则为天厨贵人。
                4、年干或日干是'丁'，并且其他地支有'午'，则为天厨贵人。
                5、年干或日干是'戊'，并且其他地支有'申'，则为天厨贵人。
                6、年干或日干是'己'，并且其他地支有'酉'，则为天厨贵人。
                7、年干或日干是'庚'，并且其他地支有'亥'，则为天厨贵人。
                8、年干或日干是'辛'，并且其他地支有'子'，则为天厨贵人。
                9、年干或日干是'壬'，并且其他地支有'寅'，则为天厨贵人。
                10、年干或日干是'癸'，并且其他地支有'卯'，则为天厨贵人。
         */ {
            put("甲", Collections.singletonList("巳"));
            put("乙", Collections.singletonList("午"));
            put("丙", Collections.singletonList("巳"));
            put("丁", Collections.singletonList("午"));
            put("戊", Collections.singletonList("申"));
            put("己", Collections.singletonList("酉"));
            put("庚", Collections.singletonList("亥"));
            put("辛", Collections.singletonList("子"));
            put("壬", Collections.singletonList("寅"));
            put("癸", Collections.singletonList("卯"));
        }
    };

    /**
     * 国印【1】
     */
    public static final Map<String, List<String>> GUO_YIN = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【国印】算法

                1、年干或日干为'甲'，并且其他地支有'戌'，则为国印。
                2、年干或日干为'乙'，并且其他地支有'亥'，则为国印。
                3、年干或日干为'丙'，并且其他地支有'丑'，则为国印。
                4、年干或日干为'丁'，并且其他地支有'寅'，则为国印。
                5、年干或日干为'戊'，并且其他地支有'丑'，则为国印。
                6、年干或日干为'己'，并且其他地支有'寅'，则为国印。
                7、年干或日干为'庚'，并且其他地支有'辰'，则为国印。
                8、年干或日干为'辛'，并且其他地支有'巳'，则为国印。
                9、年干或日干为'壬'，并且其他地支有'未'，则为国印。
                10、年干或日干为'癸'，并且其他地支有'申'，则为国印。
         */ {
            put("甲", Collections.singletonList("戌"));
            put("乙", Collections.singletonList("亥"));
            put("丙", Collections.singletonList("丑"));
            put("丁", Collections.singletonList("寅"));
            put("戊", Collections.singletonList("丑"));
            put("己", Collections.singletonList("寅"));
            put("庚", Collections.singletonList("辰"));
            put("辛", Collections.singletonList("巳"));
            put("壬", Collections.singletonList("未"));
            put("癸", Collections.singletonList("申"));
        }
    };

    /**
     * 金舆【1】
     */
    public static final Map<String, List<String>> JIN_YU = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【金舆】算法

                1、年干或日干是'甲'，并且其他地支有'辰'，则为金舆。
                2、年干或日干是'乙'，并且其他地支有'巳'，则为金舆。
                3、年干或日干是'丙'，并且其他地支有'未'，则为金舆。
                4、年干或日干是'丁'，并且其他地支有'申'，则为金舆。
                5、年干或日干是'戊'，并且其他地支有'未'，则为金舆。
                6、年干或日干是'己'，并且其他地支有'申'，则为金舆。
                7、年干或日干是'庚'，并且其他地支有'戌'，则为金舆。
                8、年干或日干是'辛'，并且其他地支有'亥'，则为金舆。
                9、年干或日干是'壬'，并且其他地支有'丑'，则为金舆。
                10、年干或日干是'癸'，并且其他地支有'寅'，则为金舆。
         */ {
            put("甲", Collections.singletonList("辰"));
            put("乙", Collections.singletonList("巳"));
            put("丙", Collections.singletonList("未"));
            put("丁", Collections.singletonList("申"));
            put("戊", Collections.singletonList("未"));
            put("己", Collections.singletonList("申"));
            put("庚", Collections.singletonList("戌"));
            put("辛", Collections.singletonList("亥"));
            put("壬", Collections.singletonList("丑"));
            put("癸", Collections.singletonList("寅"));
        }
    };

    /**
     * 驿马【1】
     */
    public static final Map<String, List<String>> YI_MA = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【驿马】算法

                1、年支或日支是'子'，并且其他地支有'寅'，则为驿马。
                2、年支或日支是'丑'，并且其他地支有'亥'，则为驿马。
                3、年支或日支是'寅'，并且其他地支有'申'，则为驿马。
                4、年支或日支是'卯'，并且其他地支有'巳'，则为驿马。
                5、年支或日支是'辰'，并且其他地支有'寅'，则为驿马。
                6、年支或日支是'巳'，并且其他地支有'亥'，则为驿马。
                7、年支或日支是'午'，并且其他地支有'申'，则为驿马。
                8、年支或日支是'未'，并且其他地支有'巳'，则为驿马。
                9、年支或日支是'申'，并且其他地支有'寅'，则为驿马。
                10、年支或日支是'酉'，并且其他地支有'亥'，则为驿马。
                11、年支或日支是'戌'，并且其他地支有'申'，则为驿马。
                12、年支或日支是'亥'，并且其他地支有'巳'，则为驿马。
         */ {
            put("子", Collections.singletonList("寅"));
            put("丑", Collections.singletonList("亥"));
            put("寅", Collections.singletonList("申"));
            put("卯", Collections.singletonList("巳"));
            put("辰", Collections.singletonList("寅"));
            put("巳", Collections.singletonList("亥"));
            put("午", Collections.singletonList("申"));
            put("未", Collections.singletonList("巳"));
            put("申", Collections.singletonList("寅"));
            put("酉", Collections.singletonList("亥"));
            put("戌", Collections.singletonList("申"));
            put("亥", Collections.singletonList("巳"));
        }
    };

    /**
     * 华盖【1】
     */
    public static final Map<String, List<String>> HUA_GAI = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【华盖】算法

                1、年支或日支是'子'，并且其他地支有'辰'，则为华盖。
                2、年支或日支是'丑'，并且其他地支有'丑'，则为华盖。
                3、年支或日支是'寅'，并且其他地支有'戌'，则为华盖。
                4、年支或日支是'卯'，并且其他地支有'未'，则为华盖。
                5、年支或日支是'辰'，并且其他地支有'辰'，则为华盖。
                6、年支或日支是'巳'，并且其他地支有'丑'，则为华盖。
                7、年支或日支是'午'，并且其他地支有'戌'，则为华盖。
                8、年支或日支是'未'，并且其他地支有'未'，则为华盖。
                9、年支或日支是'申'，并且其他地支有'辰'，则为华盖。
                10、年支或日支是'酉'，并且其他地支有'丑'，则为华盖。
                11、年支或日支是'戌'，并且其他地支有'戌'，则为华盖。
                12、年支或日支是'亥'，并且其他地支有'未'，则为华盖。
         */ {
            put("子", Collections.singletonList("辰"));
            put("丑", Collections.singletonList("丑"));
            put("寅", Collections.singletonList("戌"));
            put("卯", Collections.singletonList("未"));
            put("辰", Collections.singletonList("辰"));
            put("巳", Collections.singletonList("丑"));
            put("午", Collections.singletonList("戌"));
            put("未", Collections.singletonList("未"));
            put("申", Collections.singletonList("辰"));
            put("酉", Collections.singletonList("丑"));
            put("戌", Collections.singletonList("戌"));
            put("亥", Collections.singletonList("未"));
        }
    };

    /**
     * 劫煞【1】
     */
    public static final Map<String, List<String>> JIE_SHA = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【劫煞】算法

                1、年支或日支是'子'，并且其他地支有'巳'，则为劫煞。
                2、年支或日支是'丑'，并且其他地支有'寅'，则为劫煞。
                3、年支或日支是'寅'，并且其他地支有'亥'，则为劫煞。
                4、年支或日支是'卯'，并且其他地支有'申'，则为劫煞。
                5、年支或日支是'辰'，并且其他地支有'巳'，则为劫煞。
                6、年支或日支是'巳'，并且其他地支有'寅'，则为劫煞。
                7、年支或日支是'午'，并且其他地支有'亥'，则为劫煞。
                8、年支或日支是'未'，并且其他地支有'申'，则为劫煞。
                9、年支或日支是'申'，并且其他地支有'巳'，则为劫煞。
                10、年支或日支是'酉'，并且其他地支有'寅'，则为劫煞。
                11、年支或日支是'戌'，并且其他地支有'亥'，则为劫煞。
                12、年支或日支是'亥'，并且其他地支有'申'，则为劫煞。
        */ {
            put("子", Collections.singletonList("巳"));
            put("丑", Collections.singletonList("寅"));
            put("寅", Collections.singletonList("亥"));
            put("卯", Collections.singletonList("申"));
            put("辰", Collections.singletonList("巳"));
            put("巳", Collections.singletonList("寅"));
            put("午", Collections.singletonList("亥"));
            put("未", Collections.singletonList("申"));
            put("申", Collections.singletonList("巳"));
            put("酉", Collections.singletonList("寅"));
            put("戌", Collections.singletonList("亥"));
            put("亥", Collections.singletonList("申"));
        }
    };

    /**
     * 将星【1】
     */
    public static final Map<String, List<String>> JIANG_XING = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【将星】算法

                1、年支或日支是'子'，并且其他地支有'子'，则为将星。
                2、年支或日支是'丑'，并且其他地支有'酉'，则为将星。
                3、年支或日支是'寅'，并且其他地支有'午'，则为将星。
                4、年支或日支是'卯'，并且其他地支有'卯'，则为将星。
                5、年支或日支是'辰'，并且其他地支有'子'，则为将星。
                6、年支或日支是'巳'，并且其他地支有'酉'，则为将星。
                7、年支或日支是'午'，并且其他地支有'午'，则为将星。
                8、年支或日支是'未'，并且其他地支有'卯'，则为将星。
                9、年支或日支是'申'，并且其他地支有'子'，则为将星。
                10、年支或日支是'酉'，并且其他地支有'酉'，则为将星。
                11、年支或日支是'戌'，并且其他地支有'午'，则为将星。
                12、年支或日支是'亥'，并且其他地支有'卯'，则为将星。
         */ {
            put("子", Collections.singletonList("子"));
            put("丑", Collections.singletonList("酉"));
            put("寅", Collections.singletonList("午"));
            put("卯", Collections.singletonList("卯"));
            put("辰", Collections.singletonList("子"));
            put("巳", Collections.singletonList("酉"));
            put("午", Collections.singletonList("午"));
            put("未", Collections.singletonList("卯"));
            put("申", Collections.singletonList("子"));
            put("酉", Collections.singletonList("酉"));
            put("戌", Collections.singletonList("午"));
            put("亥", Collections.singletonList("卯"));
        }
    };

    /**
     * 桃花【1】
     */
    public static final Map<String, List<String>> TAO_HUA = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【桃花】算法

                1、年支或日支是'子'，并且其他地支有'酉'，则为桃花。
                2、年支或日支是'丑'，并且其他地支有'午'，则为桃花。
                3、年支或日支是'寅'，并且其他地支有'卯'，则为桃花。
                4、年支或日支是'卯'，并且其他地支有'子'，则为桃花。
                5、年支或日支是'辰'，并且其他地支有'酉'，则为桃花。
                6、年支或日支是'巳'，并且其他地支有'午'，则为桃花。
                7、年支或日支是'午'，并且其他地支有'卯'，则为桃花。
                8、年支或日支是'未'，并且其他地支有'子'，则为桃花。
                9、年支或日支是'申'，并且其他地支有'酉'，则为桃花。
                10、年支或日支是'酉'，并且其他地支有'午'，则为桃花。
                11、年支或日支是'戌'，并且其他地支有'卯'，则为桃花。
                12、年支或日支是'亥'，并且其他地支有'子'，则为桃花。
         */ {
            put("子", Collections.singletonList("酉"));
            put("丑", Collections.singletonList("午"));
            put("寅", Collections.singletonList("卯"));
            put("卯", Collections.singletonList("子"));
            put("辰", Collections.singletonList("酉"));
            put("巳", Collections.singletonList("午"));
            put("午", Collections.singletonList("卯"));
            put("未", Collections.singletonList("子"));
            put("申", Collections.singletonList("酉"));
            put("酉", Collections.singletonList("午"));
            put("戌", Collections.singletonList("卯"));
            put("亥", Collections.singletonList("子"));
        }

    };

    /**
     * 亡神【1】
     */
    public static final Map<String, List<String>> WANG_SHEN = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【亡神】算法

                1、年支或日支是'子'，并且其他地支有'亥'，则为亡神。
                2、年支或日支是'丑'，并且其他地支有'申'，则为亡神。
                3、年支或日支是'寅'，并且其他地支有'巳'，则为亡神。
                4、年支或日支是'卯'，并且其他地支有'寅'，则为亡神。
                5、年支或日支是'辰'，并且其他地支有'亥'，则为亡神。
                6、年支或日支是'巳'，并且其他地支有'申'，则为亡神。
                7、年支或日支是'午'，并且其他地支有'巳'，则为亡神。
                8、年支或日支是'未'，并且其他地支有'寅'，则为亡神。
                9、年支或日支是'申'，并且其他地支有'亥'，则为亡神。
                10、年支或日支是'酉'，并且其他地支有'申'，则为亡神。
                11、年支或日支是'戌'，并且其他地支有'巳'，则为亡神。
                12、年支或日支是'亥'，并且其他地支有'寅'，则为亡神。
         */ {
            put("子", Collections.singletonList(""));
            put("丑", Collections.singletonList(""));
            put("寅", Collections.singletonList(""));
            put("卯", Collections.singletonList(""));
            put("辰", Collections.singletonList(""));
            put("巳", Collections.singletonList(""));
            put("午", Collections.singletonList(""));
            put("未", Collections.singletonList(""));
            put("申", Collections.singletonList(""));
            put("酉", Collections.singletonList(""));
            put("戌", Collections.singletonList(""));
            put("亥", Collections.singletonList(""));
        }
    };

    /**
     * 丧门【1】
     */
    public static final Map<String, List<String>> SANG_MEN = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【丧门】算法

                1、年支或日支是'子'，并且其他地支有'寅'，则为丧门。
                2、年支或日支是'丑'，并且其他地支有'卯'，则为丧门。
                3、年支或日支是'寅'，并且其他地支有'辰'，则为丧门。
                4、年支或日支是'卯'，并且其他地支有'巳'，则为丧门。
                5、年支或日支是'辰'，并且其他地支有'午'，则为丧门。
                6、年支或日支是'巳'，并且其他地支有'未'，则为丧门。
                7、年支或日支是'午'，并且其他地支有'申'，则为丧门。
                8、年支或日支是'未'，并且其他地支有'酉'，则为丧门。
                9、年支或日支是'申'，并且其他地支有'戌'，则为丧门。
                10、年支或日支是'酉'，并且其他地支有'寅'，则为丧门。
                11、年支或日支是'戌'，并且其他地支有'卯'，则为丧门。
                12、年支或日支是'亥'，并且其他地支有'辰'，则为丧门。
         */ {
            put("子", Collections.singletonList("寅"));
            put("丑", Collections.singletonList("卯"));
            put("寅", Collections.singletonList("辰"));
            put("卯", Collections.singletonList("巳"));
            put("辰", Collections.singletonList("午"));
            put("巳", Collections.singletonList("未"));
            put("午", Collections.singletonList("申"));
            put("未", Collections.singletonList("酉"));
            put("申", Collections.singletonList("戌"));
            put("酉", Collections.singletonList("寅"));
            put("戌", Collections.singletonList("卯"));
            put("亥", Collections.singletonList("辰"));
        }
    };

    /**
     * 吊客【1】
     */
    public static final Map<String, List<String>> DIAO_KE = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【吊客】算法

                1、年支或日支是'子'，并且其他地支有'戌'，则为吊客。
                2、年支或日支是'丑'，并且其他地支有'亥'，则为吊客。
                3、年支或日支是'寅'，并且其他地支有'子'，则为吊客。
                4、年支或日支是'卯'，并且其他地支有'丑'，则为吊客。
                5、年支或日支是'辰'，并且其他地支有'寅'，则为吊客。
                6、年支或日支是'巳'，并且其他地支有'卯'，则为吊客。
                7、年支或日支是'午'，并且其他地支有'辰'，则为吊客。
                8、年支或日支是'未'，并且其他地支有'巳'，则为吊客。
                9、年支或日支是'申'，并且其他地支有'午'，则为吊客。
                10、年支或日支是'酉'，并且其他地支有'未'，则为吊客。
                11、年支或日支是'戌'，并且其他地支有'申'，则为吊客。
                12、年支或日支是'亥'，并且其他地支有'酉'，则为吊客。
         */ {
            put("子", Collections.singletonList("戌"));
            put("丑", Collections.singletonList("亥"));
            put("寅", Collections.singletonList("子"));
            put("卯", Collections.singletonList("丑"));
            put("辰", Collections.singletonList("寅"));
            put("巳", Collections.singletonList("卯"));
            put("午", Collections.singletonList("辰"));
            put("未", Collections.singletonList("巳"));
            put("申", Collections.singletonList("午"));
            put("酉", Collections.singletonList("未"));
            put("戌", Collections.singletonList("申"));
            put("亥", Collections.singletonList("酉"));
        }
    };

    /**
     * 披麻【1】
     */
    public static final Map<String, List<String>> PI_MA = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【披麻】算法

                1、年支或日支是'子'，并且其他地支有'酉'，则为披麻。
                2、年支或日支是'丑'，并且其他地支有'戌'，则为披麻。
                3、年支或日支是'寅'，并且其他地支有'亥'，则为披麻。
                4、年支或日支是'卯'，并且其他地支有'子'，则为披麻。
                5、年支或日支是'辰'，并且其他地支有'丑'，则为披麻。
                6、年支或日支是'巳'，并且其他地支有'寅'，则为披麻。
                7、年支或日支是'午'，并且其他地支有'卯'，则为披麻。
                8、年支或日支是'未'，并且其他地支有'辰'，则为披麻。
                9、年支或日支是'申'，并且其他地支有'巳'，则为披麻。
                10、年支或日支是'酉'，并且其他地支有'午'，则为披麻。
                11、年支或日支是'戌'，并且其他地支有'未'，则为披麻。
                12、年支或日支是'亥'，并且其他地支有'申'，则为披麻。
         */ {
            put("子", Collections.singletonList("酉"));
            put("丑", Collections.singletonList("戌"));
            put("寅", Collections.singletonList("亥"));
            put("卯", Collections.singletonList("子"));
            put("辰", Collections.singletonList("丑"));
            put("巳", Collections.singletonList("寅"));
            put("午", Collections.singletonList("卯"));
            put("未", Collections.singletonList("辰"));
            put("申", Collections.singletonList("巳"));
            put("酉", Collections.singletonList("午"));
            put("戌", Collections.singletonList("未"));
            put("亥", Collections.singletonList("申"));
        }
    };

    /**
     * 十恶大败（日柱）【2】
     */
    public static final String[] SHI_E_DA_BAI = {"甲辰", "乙巳", "丙申", "丁亥", "戊戌", "己丑", "庚辰", "辛巳", "壬申", "癸亥"};

    /**
     * 阴差阳错（日柱）【2】
     */
    public static final String[] YIN_CHA_YANG_CUO = {"丙午", "丙子", "丁未", "丁丑", "戊申", "戊寅", "辛酉", "辛卯", "壬戌", "壬辰", "癸巳", "癸亥"};

    /**
     * 六秀日（日柱）【2】
     */
    public static final String[] LIU_XIU_RI = {"丙午", "丁未", "戊子", "戊午", "己丑", "己未"};

    /**
     * 十灵日（日柱）【2】
     */
    public static final String[] SHI_LING_RI = {"甲辰", "乙亥", "丙辰", "丁酉", "戊午", "庚戌", "庚寅", "辛亥", "壬寅", "癸未"};

    /**
     * 魁罡日（日柱）【2】
     */
    public static final String[] KUI_GANG_RI = {"戊戌", "庚辰", "庚戌", "壬辰"};

    /**
     * 八专日（日柱）【2】
     */
    public static final String[] BA_ZHUAN_RI = {"甲寅", "乙卯", "丁未", "戊戌", "己未", "庚申", "辛酉", "癸丑"};

    /**
     * 九丑日（日柱）【2】
     */
    public static final String[] JIU_CHOU_RI = {"戊子", "丁酉", "丁卯", "戊午", "己酉", "己卯", "壬子", "壬午", "辛卯"};

    /**
     * 红艳煞【3】
     */
    public static final Map<String, String> HONG_YAN_SHA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【红艳煞】算法

                1、日干是'甲'，并且其他地支有'午'，则为红艳煞。
                2、日干是'乙'，并且其他地支有'申'，则为红艳煞。
                3、日干是'丙'，并且其他地支有'寅'，则为红艳煞。
                4、日干是'丁'，并且其他地支有'未'，则为红艳煞。
                5、日干是'戊'，并且其他地支有'辰'，则为红艳煞。
                6、日干是'己'，并且其他地支有'辰'，则为红艳煞。
                7、日干是'庚'，并且其他地支有'戌'，则为红艳煞。
                8、日干是'辛'，并且其他地支有'酉'，则为红艳煞。
                9、日干是'壬'，并且其他地支有'子'，则为红艳煞。
                10、日干是'癸'，并且其他地支有'申'，则为红艳煞。
         */ {
            put("甲", "午");
            put("乙", "申");
            put("丙", "寅");
            put("丁", "未");
            put("戊", "辰");
            put("己", "辰");
            put("庚", "戌");
            put("辛", "酉");
            put("壬", "子");
            put("癸", "申");
        }
    };

    /**
     * 羊刃【3】
     */
    public static final Map<String, String> YANG_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【羊刃】算法

                1、日干是'甲'，并且其他地支有'卯'，则为羊刃。
                2、日干是'乙'，并且其他地支有'辰'，则为羊刃。
                3、日干是'丙'，并且其他地支有'午'，则为羊刃。
                4、日干是'丁'，并且其他地支有'未'，则为羊刃。
                5、日干是'戊'，并且其他地支有'午'，则为羊刃。
                6、日干是'己'，并且其他地支有'未'，则为羊刃。
                7、日干是'庚'，并且其他地支有'酉'，则为羊刃。
                8、日干是'辛'，并且其他地支有'戌'，则为羊刃。
                9、日干是'壬'，并且其他地支有'子'，则为羊刃。
                10、日干是'癸'，并且其他地支有'丑'，则为羊刃。
         */ {
            put("甲", "卯");
            put("乙", "辰");
            put("丙", "午");
            put("丁", "未");
            put("戊", "午");
            put("己", "未");
            put("庚", "酉");
            put("辛", "戌");
            put("壬", "子");
            put("癸", "丑");
        }
    };

    /**
     * 飞刃【3】
     */
    public static final Map<String, String> FEI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【飞刃】算法

                1、日干是'甲'，并且其他地支有'酉'，则为飞刃。
                2、日干是'乙'，并且其他地支有'寅'，则为飞刃。
                3、日干是'丙'，并且其他地支有'子'，则为飞刃。
                4、日干是'丁'，并且其他地支有'亥'，则为飞刃。
                5、日干是'戊'，并且其他地支有''，则为飞刃。
                6、日干是'己'，并且其他地支有''，则为飞刃。
                7、日干是'庚'，并且其他地支有'卯'，则为飞刃。
                8、日干是'辛'，并且其他地支有'寅'，则为飞刃。
                9、日干是'壬'，并且其他地支有'午'，则为飞刃。
                10、日干是'癸'，并且其他地支有'巳'，则为飞刃。
         */ {
            put("甲", "酉");
            put("乙", "寅");
            put("丙", "子");
            put("丁", "亥");
            put("戊", "");
            put("己", "");
            put("庚", "卯");
            put("辛", "寅");
            put("壬", "午");
            put("癸", "巳");
        }
    };

    /**
     * 血刃【3】
     */
    public static final Map<String, String> XUE_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【血刃】算法

                1、月支是'子'，并且其他地支有'午'，则为血刃。
                2、月支是'丑'，并且其他地支有'子'，则为血刃。
                3、月支是'寅'，并且其他地支有'丑'，则为血刃。
                4、月支是'卯'，并且其他地支有'未'，则为血刃。
                5、月支是'辰'，并且其他地支有'寅'，则为血刃。
                6、月支是'巳'，并且其他地支有'申'，则为血刃。
                7、月支是'午'，并且其他地支有'卯'，则为血刃。
                8、月支是'未'，并且其他地支有'酉'，则为血刃。
                9、月支是'申'，并且其他地支有'辰'，则为血刃。
                10、月支是'酉'，并且其他地支有'戌'，则为血刃。
                11、月支是'戌'，并且其他地支有'巳'，则为血刃。
                12、月支是'亥'，并且其他地支有'亥'，则为血刃。
         */ {
            put("子", "午");
            put("丑", "子");
            put("寅", "丑");
            put("卯", "未");
            put("辰", "寅");
            put("巳", "申");
            put("午", "卯");
            put("未", "酉");
            put("申", "辰");
            put("酉", "戌");
            put("戌", "巳");
            put("亥", "亥");
        }
    };

    /**
     * 流霞【3】
     */
    public static final Map<String, String> LIU_XIA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【流霞】算法

                1、日干是'甲'，并且其他地支有'酉'，则为流霞。
                2、日干是'乙'，并且其他地支有'戌'，则为流霞。
                3、日干是'丙'，并且其他地支有'未'，则为流霞。
                4、日干是'丁'，并且其他地支有'申'，则为流霞。
                5、日干是'戊'，并且其他地支有'巳'，则为流霞。
                6、日干是'己'，并且其他地支有'午'，则为流霞。
                7、日干是'庚'，并且其他地支有'辰'，则为流霞。
                8、日干是'辛'，并且其他地支有'卯'，则为流霞。
                9、日干是'壬'，并且其他地支有'亥'，则为流霞。
                10、日干是'癸'，并且其他地支有'寅'，则为流霞。
         */ {
            put("甲", "酉");
            put("乙", "戌");
            put("丙", "未");
            put("丁", "申");
            put("戊", "巳");
            put("己", "午");
            put("庚", "辰");
            put("辛", "卯");
            put("壬", "亥");
            put("癸", "寅");
        }
    };

    /**
     * 天医【3】
     */
    public static final Map<String, String> TIAN_YI = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【天医】算法

                1、月支是'子'，并且其他地支有'亥'，则为天医。
                2、月支是'丑'，并且其他地支有'子'，则为天医。
                3、月支是'寅'，并且其他地支有'丑'，则为天医。
                4、月支是'卯'，并且其他地支有'寅'，则为天医。
                5、月支是'辰'，并且其他地支有'卯'，则为天医。
                6、月支是'巳'，并且其他地支有'辰'，则为天医。
                7、月支是'午'，并且其他地支有'巳'，则为天医。
                8、月支是'未'，并且其他地支有'午'，则为天医。
                9、月支是'申'，并且其他地支有'未'，则为天医。
                10、月支是'酉'，并且其他地支有'申'，则为天医。
                11、月支是'戌'，并且其他地支有'酉'，则为天医。
                12、月支是'亥'，并且其他地支有'戌'，则为天医。
         */ {
            put("子", "亥");
            put("丑", "子");
            put("寅", "丑");
            put("卯", "寅");
            put("辰", "卯");
            put("巳", "辰");
            put("午", "巳");
            put("未", "午");
            put("申", "未");
            put("酉", "申");
            put("戌", "酉");
            put("亥", "戌");
        }
    };

    /**
     * 天喜【3】
     */
    public static final Map<String, String> TIAN_XI = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【天喜】算法

                1、年支是'子'，并且其他地支有'酉'，则为天喜。
                2、年支是'丑'，并且其他地支有'申'，则为天喜。
                3、年支是'寅'，并且其他地支有'未'，则为天喜。
                4、年支是'卯'，并且其他地支有'午'，则为天喜。
                5、年支是'辰'，并且其他地支有'巳'，则为天喜。
                6、年支是'巳'，并且其他地支有'辰'，则为天喜。
                7、年支是'午'，并且其他地支有'卯'，则为天喜。
                8、年支是'未'，并且其他地支有'寅'，则为天喜。
                9、年支是'申'，并且其他地支有'丑'，则为天喜。
                10、年支是'酉'，并且其他地支有'子'，则为天喜。
                11、年支是'戌'，并且其他地支有'亥'，则为天喜。
                12、年支是'亥'，并且其他地支有'戌'，则为天喜。
         */ {
            put("子", "酉");
            put("丑", "申");
            put("寅", "未");
            put("卯", "午");
            put("辰", "巳");
            put("巳", "辰");
            put("午", "卯");
            put("未", "寅");
            put("申", "丑");
            put("酉", "子");
            put("戌", "亥");
            put("亥", "戌");
        }
    };

    /**
     * 红鸾【3】
     */
    public static final Map<String, String> HONG_LUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【红鸾】算法

                1、年支是'子'，并且其他地支有'卯'，则为红鸾。
                2、年支是'丑'，并且其他地支有'寅'，则为红鸾。
                3、年支是'寅'，并且其他地支有'丑'，则为红鸾。
                4、年支是'卯'，并且其他地支有'子'，则为红鸾。
                5、年支是'辰'，并且其他地支有'亥'，则为红鸾。
                6、年支是'巳'，并且其他地支有'戌'，则为红鸾。
                7、年支是'午'，并且其他地支有'酉'，则为红鸾。
                8、年支是'未'，并且其他地支有'申'，则为红鸾。
                9、年支是'申'，并且其他地支有'未'，则为红鸾。
                10、年支是'酉'，并且其他地支有'午'，则为红鸾。
                11、年支是'戌'，并且其他地支有'巳'，则为红鸾。
                12、年支是'亥'，并且其他地支有'辰'，则为红鸾。
         */ {
            put("子", "卯");
            put("丑", "寅");
            put("寅", "丑");
            put("卯", "子");
            put("辰", "亥");
            put("巳", "戌");
            put("午", "酉");
            put("未", "申");
            put("申", "未");
            put("酉", "午");
            put("戌", "巳");
            put("亥", "辰");
        }
    };

    /**
     * 灾煞【3】
     */
    public static final Map<String, String> ZAI_SHA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【灾煞】算法

                1、年支是'子'，并且其他地支有'午'，则为灾煞。
                2、年支是'丑'，并且其他地支有'卯'，则为灾煞。
                3、年支是'寅'，并且其他地支有'子'，则为灾煞。
                4、年支是'卯'，并且其他地支有'酉'，则为灾煞。
                5、年支是'辰'，并且其他地支有'午'，则为灾煞。
                6、年支是'巳'，并且其他地支有'卯'，则为灾煞。
                7、年支是'午'，并且其他地支有'子'，则为灾煞。
                8、年支是'未'，并且其他地支有'酉'，则为灾煞。
                9、年支是'申'，并且其他地支有'午'，则为灾煞。
                10、年支是'酉'，并且其他地支有'卯'，则为灾煞。
                11、年支是'戌'，并且其他地支有'子'，则为灾煞。
                12、年支是'亥'，并且其他地支有'酉'，则为灾煞。
         */ {
            put("子", "午");
            put("丑", "卯");
            put("寅", "子");
            put("卯", "酉");
            put("辰", "午");
            put("巳", "卯");
            put("午", "子");
            put("未", "酉");
            put("申", "午");
            put("酉", "卯");
            put("戌", "子");
            put("亥", "酉");
        }
    };

    /**
     * 孤辰【3】
     */
    public static final Map<String, String> GU_CHEN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【孤辰】算法

                1、年支是'子'，并且其他地支有'寅'，则为孤辰。
                2、年支是'丑'，并且其他地支有'寅'，则为孤辰。
                3、年支是'寅'，并且其他地支有'巳'，则为孤辰。
                4、年支是'卯'，并且其他地支有'巳'，则为孤辰。
                5、年支是'辰'，并且其他地支有'巳'，则为孤辰。
                6、年支是'巳'，并且其他地支有'申'，则为孤辰。
                7、年支是'午'，并且其他地支有'申'，则为孤辰。
                8、年支是'未'，并且其他地支有'申'，则为孤辰。
                9、年支是'申'，并且其他地支有'亥'，则为孤辰。
                10、年支是'酉'，并且其他地支有'亥'，则为孤辰。
                11、年支是'戌'，并且其他地支有'亥'，则为孤辰。
                12、年支是'亥'，并且其他地支有'寅'，则为孤辰。
         */ {
            put("子", "寅");
            put("丑", "寅");
            put("寅", "巳");
            put("卯", "巳");
            put("辰", "巳");
            put("巳", "申");
            put("午", "申");
            put("未", "申");
            put("申", "亥");
            put("酉", "亥");
            put("戌", "亥");
            put("亥", "寅");
        }
    };

    /**
     * 寡宿【3】
     */
    public static final Map<String, String> SU_GUA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【寡宿】算法

                1、年支是'子'，并且其他地支有'戌'，则为寡宿。
                2、年支是'丑'，并且其他地支有'戌'，则为寡宿。
                3、年支是'寅'，并且其他地支有'丑'，则为寡宿。
                4、年支是'卯'，并且其他地支有'丑'，则为寡宿。
                5、年支是'辰'，并且其他地支有'丑'，则为寡宿。
                6、年支是'巳'，并且其他地支有'辰'，则为寡宿。
                7、年支是'午'，并且其他地支有'辰'，则为寡宿。
                8、年支是'未'，并且其他地支有'辰'，则为寡宿。
                9、年支是'申'，并且其他地支有'未'，则为寡宿。
                10、年支是'酉'，并且其他地支有'未'，则为寡宿。
                11、年支是'戌'，并且其他地支有'未'，则为寡宿。
                12、年支是'亥'，并且其他地支有'戌'，则为寡宿。
         */ {
            put("子", "戌");
            put("丑", "戌");
            put("寅", "丑");
            put("卯", "丑");
            put("辰", "丑");
            put("巳", "辰");
            put("午", "辰");
            put("未", "辰");
            put("申", "未");
            put("酉", "未");
            put("戌", "未");
            put("亥", "戌");
        }
    };

    /**
     * 禄神【3】
     */
    public static final Map<String, String> LU_SHEN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【禄神】算法

                1、日干是'甲'，并且其他地支有'寅'，则为禄神。
                2、日干是'乙'，并且其他地支有'卯'，则为禄神。
                3、日干是'丙'，并且其他地支有'巳'，则为禄神。
                4、日干是'丁'，并且其他地支有'午'，则为禄神。
                5、日干是'戊'，并且其他地支有'巳'，则为禄神。
                6、日干是'己'，并且其他地支有'午'，则为禄神。
                7、日干是'庚'，并且其他地支有'申'，则为禄神。
                8、日干是'辛'，并且其他地支有'酉'，则为禄神。
                9、日干是'壬'，并且其他地支有'亥'，则为禄神。
                10、日干是'癸'，并且其他地支有'子'，则为禄神。
         */ {
            put("甲", "寅");
            put("乙", "卯");
            put("丙", "巳");
            put("丁", "午");
            put("戊", "巳");
            put("己", "午");
            put("庚", "申");
            put("辛", "酉");
            put("壬", "亥");
            put("癸", "子");
        }
    };

    /**
     * 词馆【4】
     */
    public static final Map<String, List<String>> CI_GUAN = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【词馆】算法

                一、禄命法：（以年柱纳音查月支、日支、时支）
                    1、年命属木，月支或日支或时支有'寅'，则为词馆。（'庚寅'为正词馆）
                    2、年命属火，月支或日支或时支有'巳'，则为词馆。（'乙巳'为正词馆）
                    3、年命属土，月支或日支或时支有'亥'，则为词馆。（'丁亥'为正词馆）
                    4、年命属金，月支或日支或时支有'申'，则为词馆。（'壬申'为正词馆）
                    5、年命属水，月支或日支或时支有'亥'，则为词馆。（'癸亥'为正词馆）

                二、子平法：（以年干、日干查四柱）
                    1、年干或日干为'甲'，并且其他天干地支有'已'或者'亥'，则为词馆。
                    2、年干或日干为'乙'，并且其他天干地支有'壬'或者'午'，则为词馆。
                    3、年干或日干为'丙'，并且其他天干地支有'丙'或者'寅'，则为词馆。
                    4、年干或日干为'丁'，并且其他天干地支有'丁'或者'酉'，则为词馆。
                    5、年干或日干为'戊'，并且其他天干地支有'戊'或者'寅'，则为词馆。
                    6、年干或日干为'己'，并且其他天干地支有'己'或者'酉'，则为词馆。
                    7、年干或日干为'庚'，并且其他天干地支有'辛'或者'巳'，则为词馆。
                    8、年干或日干为'辛'，并且其他天干地支有'甲'或者'子'，则为词馆。
                    9、年干或日干为'壬'，并且其他天干地支有'甲'或者'申'，则为词馆。
                    10、年干或日干为'癸'，并且其他天干地支有'乙'或者'卯'，则为词馆。
         */ {
            put("甲", Arrays.asList("已", "亥"));
            put("乙", Arrays.asList("壬", "午"));
            put("丙", Arrays.asList("丙", "寅"));
            put("丁", Arrays.asList("丁", "酉"));
            put("戊", Arrays.asList("戊", "寅"));
            put("己", Arrays.asList("己", "酉"));
            put("庚", Arrays.asList("辛", "巳"));
            put("辛", Arrays.asList("甲", "子"));
            put("壬", Arrays.asList("甲", "申"));
            put("癸", Arrays.asList("乙", "卯"));
        }
    };

    /**
     * 学堂【4】
     */
    public static final Map<String, List<String>> XUE_TANG = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【学堂】算法

                一、禄命法：（以年柱纳音查月支、日支、时支）
                    1、年命属木，月支或日支或时支有'亥'，则为学堂。（'己亥'为正学堂）
                    2、年命属火，月支或日支或时支有'寅'，则为学堂。（'丙寅'为正学堂）
                    3、年命属土，月支或日支或时支有'申'，则为学堂。（'戊申'为正学堂）
                    4、年命属金，月支或日支或时支有'巳'，则为学堂。（'辛巳'为正学堂）
                    5、年命属水，月支或日支或时支有'申'，则为学堂。（'甲申'为正学堂）

                二、子平法：（以年干、日干查四柱）
                    1、年干或日干为'甲'，并且其他天干地支有'已'或者'亥'，则为学堂。
                    2、年干或日干为'乙'，并且其他天干地支有'壬'或者'午'，则为学堂。
                    3、年干或日干为'丙'，并且其他天干地支有'丙'或者'寅'，则为学堂。
                    4、年干或日干为'丁'，并且其他天干地支有'丁'或者'酉'，则为学堂。
                    5、年干或日干为'戊'，并且其他天干地支有'戊'或者'寅'，则为学堂。
                    6、年干或日干为'己'，并且其他天干地支有'己'或者'酉'，则为学堂。
                    7、年干或日干为'庚'，并且其他天干地支有'辛'或者'巳'，则为学堂。
                    8、年干或日干为'辛'，并且其他天干地支有'甲'或者'子'，则为学堂。
                    9、年干或日干为'壬'，并且其他天干地支有'甲'或者'申'，则为学堂。
                    10、年干或日干为'癸'，并且其他天干地支有'乙'或者'卯'，则为学堂。
         */ {
            put("甲", Arrays.asList("已", "亥"));
            put("乙", Arrays.asList("壬", "午"));
            put("丙", Arrays.asList("丙", "寅"));
            put("丁", Arrays.asList("丁", "酉"));
            put("戊", Arrays.asList("戊", "寅"));
            put("己", Arrays.asList("己", "酉"));
            put("庚", Arrays.asList("辛", "巳"));
            put("辛", Arrays.asList("甲", "子"));
            put("壬", Arrays.asList("甲", "申"));
            put("癸", Arrays.asList("乙", "卯"));
        }
    };

    /**
     * 天德贵人【∞】
     */
    public static final Map<String, String> TIAN_DE_GUI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【天德贵人】算法

                1、月支是'子'，并且其他地支有'巳'，则为天德贵人。
                2、月支是'丑'，并且其他天干有'庚'，则为天德贵人。
                3、月支是'寅'，并且其他天干有'丁'，则为天德贵人。
                4、月支是'卯'，并且其他地支有'申'，则为天德贵人。
                5、月支是'辰'，并且其他天干有'壬'，则为天德贵人。
                6、月支是'巳'，并且其他天干有'辛'，则为天德贵人。
                7、月支是'午'，并且其他地支有'亥'，则为天德贵人。
                8、月支是'未'，并且其他天干有'甲'，则为天德贵人。
                9、月支是'申'，并且其他天干有'癸'，则为天德贵人。
                10、月支是'酉'，并且其他地支有'寅'，则为天德贵人。
                11、月支是'戌'，并且其他天干有'丙'，则为天德贵人。
                12、月支是'亥'，并且其他天干有'乙'，则为天德贵人。
         */ {
            put("子", "巳");
            put("丑", "庚");
            put("寅", "丁");
            put("卯", "申");
            put("辰", "壬");
            put("巳", "辛");
            put("午", "亥");
            put("未", "甲");
            put("申", "癸");
            put("酉", "寅");
            put("戌", "丙");
            put("亥", "乙");
        }
    };

    /**
     * 月德贵人【∞】
     */
    public static final Map<String, String> YUE_DE_GUI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【月德贵人】算法

                1、月支是'子'，并且其他天干有'壬'，则为月德贵人。
                2、月支是'丑'，并且其他天干有'庚'，则为月德贵人。
                3、月支是'寅'，并且其他天干有'丙'，则为月德贵人。
                4、月支是'卯'，并且其他天干有'甲'，则为月德贵人。
                5、月支是'辰'，并且其他天干有'壬'，则为月德贵人。
                6、月支是'巳'，并且其他天干有'庚'，则为月德贵人。
                7、月支是'午'，并且其他天干有'丙'，则为月德贵人。
                8、月支是'未'，并且其他天干有'甲'，则为月德贵人。
                9、月支是'申'，并且其他天干有'壬'，则为月德贵人。
                10、月支是'酉'，并且其他天干有'庚'，则为月德贵人。
                11、月支是'戌'，并且其他天干有'丙'，则为月德贵人。
                12、月支是'亥'，并且其他天干有'甲'，则为月德贵人。
         */ {
            put("子", "壬");
            put("丑", "庚");
            put("寅", "丙");
            put("卯", "甲");
            put("辰", "壬");
            put("巳", "庚");
            put("午", "丙");
            put("未", "甲");
            put("申", "壬");
            put("酉", "庚");
            put("戌", "丙");
            put("亥", "甲");
        }
    };

    /**
     * 德秀贵人【∞】
     */
    public static final Map<String, List<String>> DE_XIU_GUI_REN = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【德秀贵人】算法

                1、月支是'子'，并且其他天干有'甲'或者'丙'或者'戊'或者'己'或者'辛'或者'壬'或者'癸'，则为德秀贵人。
                2、月支是'丑'，并且其他天干有'乙'或者'庚'或者'辛'，则为德秀贵人。
                3、月支是'寅'，并且其他天干有'丙'或者'丁'或者'戊'或者'癸'，则为德秀贵人。
                4、月支是'卯'，并且其他天干有'甲'或者'乙'或者'丁'或者'壬'，则为德秀贵人。
                5、月支是'辰'，并且其他天干有'甲'或者'丙'或者'戊'或者'己'或者'辛'或者'壬'或者'癸'，则为德秀贵人。
                6、月支是'巳'，并且其他天干有'乙'或者'庚'或者'辛'，则为德秀贵人。
                7、月支是'午'，并且其他天干有'丙'或者'丁'或者'戊'或者'癸'，则为德秀贵人。
                8、月支是'未'，并且其他天干有'甲'或者'乙'或者'丁'或者'壬'，则为德秀贵人。
                9、月支是'申'，并且其他天干有'甲'或者'丙'或者'戊'或者'己'或者'辛'或者'壬'或者'癸'，则为德秀贵人。
                10、月支是'酉'，并且其他天干有'乙'或者'庚'或者'辛'，则为德秀贵人。
                11、月支是'戌'，并且其他天干有'丙'或者'丁'或者'戊'或者'癸'，则为德秀贵人。
                12、月支是'亥'，并且其他天干有'甲'或者'乙'或者'丁'或者'壬'，则为德秀贵人。
         */ {
            put("子", Arrays.asList("甲", "丙", "戊", "己", "辛", "壬", "癸"));
            put("丑", Arrays.asList("乙", "庚", "辛"));
            put("寅", Arrays.asList("丙", "丁", "戊", "癸"));
            put("卯", Arrays.asList("甲", "乙", "丁", "壬"));
            put("辰", Arrays.asList("甲", "丙", "戊", "己", "辛", "壬", "癸"));
            put("巳", Arrays.asList("乙", "庚", "辛"));
            put("午", Arrays.asList("丙", "丁", "戊", "癸"));
            put("未", Arrays.asList("甲", "乙", "丁", "壬"));
            put("申", Arrays.asList("甲", "丙", "戊", "己", "辛", "壬", "癸"));
            put("酉", Arrays.asList("乙", "庚", "辛"));
            put("戌", Arrays.asList("丙", "丁", "戊", "癸"));
            put("亥", Arrays.asList("甲", "乙", "丁", "壬"));
        }
    };

    /**
     * 三奇贵人（年干+月干+日干 或 月干+日干+时干）【∞】
     */
    public static final String[] SAN_QI_GUI_REN = {"甲戊庚", "乙丙丁", "壬癸辛", "庚戊甲", "丁丙乙", "辛癸壬"};

    /**
     * 四废日【∞】
     */
    public static final Map<String, List<String>> SI_FEI_RI = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【四废日】算法

                1、春季，庚申日、辛酉日。
                2、夏季，壬子日、癸亥日。
                3、秋季，甲寅日、乙卯日。
                4、冬季，丙午日、丁巳日。
         */ {
            put("春", Arrays.asList("庚申", "辛酉"));
            put("夏", Arrays.asList("壬子", "癸亥"));
            put("秋", Arrays.asList("甲寅", "乙卯"));
            put("冬", Arrays.asList("丙午", "丁巳"));
        }
    };

    /**
     * 拱禄【∞】
     */
    public static final Map<List<String>, String> GONG_LU = new HashMap<List<String>, String>() {
        private static final long serialVersionUID = -1;

        /*
            【拱禄】算法

                1、日柱是'癸亥'、时柱是'癸丑'，则拱禄在'子'。
                2、日柱是'癸丑'、时柱是'癸亥'，则拱禄在'子'。
                3、日柱是'丁巳'、时柱是'丁未'，则拱禄在'午'。
                4、日柱是'己未'、时柱是'己巳'，则拱禄在'午'。
                5、日柱是'戊辰'、时柱是'戊午'，则拱禄在'巳'。
         */ {
            put(Arrays.asList("癸亥", "癸丑"), "子");
            put(Arrays.asList("癸丑", "癸亥"), "子");
            put(Arrays.asList("丁巳", "丁未"), "午");
            put(Arrays.asList("己未", "己巳"), "午");
            put(Arrays.asList("戊辰", "戊午"), "巳");
        }
    };

    /**
     * 天赦【∞】
     */
    public static final Map<String, String> TIAN_SHE = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【天赦】算法

                1、月支是'子'，日柱为'甲子'，则为天赦。
                2、月支是'丑'，日柱为'甲子'，则为天赦。
                3、月支是'寅'，日柱为'戊寅'，则为天赦。
                4、月支是'卯'，日柱为'戊寅'，则为天赦。
                5、月支是'辰'，日柱为'戊寅'，则为天赦。
                6、月支是'巳'，日柱为'甲午'，则为天赦。
                7、月支是'午'，日柱为'甲午'，则为天赦。
                8、月支是'未'，日柱为'甲午'，则为天赦。
                9、月支是'申'，日柱为'戊申'，则为天赦。
                10、月支是'酉'，日柱为'戊申'，则为天赦。
                11、月支是'戌'，日柱为'戊申'，则为天赦。
                12、月支是'亥'，日柱为'甲子'，则为天赦。
         */ {
            put("子", "甲子");
            put("丑", "甲子");
            put("寅", "戊寅");
            put("卯", "戊寅");
            put("辰", "戊寅");
            put("巳", "甲午");
            put("午", "甲午");
            put("未", "甲午");
            put("申", "戊申");
            put("酉", "戊申");
            put("戌", "戊申");
            put("亥", "甲子");
        }
    };

    /**
     * 天转【∞】
     */
    public static final Map<String, String> TIAN_ZHUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【天转】算法

                1、月支是'子'、日柱是'壬子'，则为天转。
                2、月支是'丑'、日柱是'壬子'，则为天转。
                3、月支是'寅'、日柱是'乙卯'，则为天转。
                4、月支是'卯'、日柱是'乙卯'，则为天转。
                5、月支是'辰'、日柱是'乙卯'，则为天转。
                6、月支是'巳'、日柱是'丙午'，则为天转。
                7、月支是'午'、日柱是'丙午'，则为天转。
                8、月支是'未'、日柱是'丙午'，则为天转。
                9、月支是'申'、日柱是'辛酉'，则为天转。
                10、月支是'酉'、日柱是'辛酉'，则为天转。
                11、月支是'戌'、日柱是'辛酉'，则为天转。
                12、月支是'亥'、日柱是'壬子'，则为天转。
         */ {
            put("子", "壬子");
            put("丑", "壬子");
            put("寅", "乙卯");
            put("卯", "乙卯");
            put("辰", "乙卯");
            put("巳", "丙午");
            put("午", "丙午");
            put("未", "丙午");
            put("申", "辛酉");
            put("酉", "辛酉");
            put("戌", "辛酉");
            put("亥", "壬子");
        }
    };

    /**
     * 地转【∞】
     */
    public static final Map<String, String> DI_ZHUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【地转】算法

                1、月支是'子'、日柱是'丙子'，则为地转。
                2、月支是'丑'、日柱是'丙子'，则为地转。
                3、月支是'寅'、日柱是'辛卯'，则为地转。
                4、月支是'卯'、日柱是'辛卯'，则为地转。
                5、月支是'辰'、日柱是'辛卯'，则为地转。
                6、月支是'巳'、日柱是'戊午'，则为地转。
                7、月支是'午'、日柱是'戊午'，则为地转。
                8、月支是'未'、日柱是'戊午'，则为地转。
                9、月支是'申'、日柱是'癸酉'，则为地转。
                10、月支是'酉'、日柱是'癸酉'，则为地转。
                11、月支是'戌'、日柱是'癸酉'，则为地转。
                12、月支是'亥'、日柱是'丙子'，则为地转。
         */ {
            put("子", "丙子");
            put("丑", "丙子");
            put("寅", "辛卯");
            put("卯", "辛卯");
            put("辰", "辛卯");
            put("巳", "戊午");
            put("午", "戊午");
            put("未", "戊午");
            put("申", "癸酉");
            put("酉", "癸酉");
            put("戌", "癸酉");
            put("亥", "丙子");
        }
    };


}
